OsQueue.h

Go to the documentation of this file.

 
#ifndef OS_QUEUE_H_
#define OS_QUEUE_H_
 
#include <cstdint>
#include <cstddef>
#include <climits>
#include <cstring>
#include <type_traits>
#include "OsAbstraction.h"
#include "OsUtility.h"
 
template <typename MessageType, size_t kCapacity>
class OsQueue {
    static_assert(std::is_trivially_copyable_v<MessageType>,
                  "OsQueue<T, N> requires a trivially copyable T");
    static_assert(kCapacity > 0, "OsQueue<T, N> needs a capacity of at least 1");
 
public:
    explicit OsQueue(const char* queueName) noexcept
        : name_(queueName)
    {
        created_ = os_queue_create_ex(queue_, name_, static_cast<OS_Uint>(kItemWords),
                                      storage_, static_cast<OS_Ulong>(kCapacity));
    }
 
    OsQueue(const OsQueue&) = delete;
    OsQueue& operator=(const OsQueue&) = delete;
 
    ~OsQueue() noexcept
    {
        if (created_) {
            os_queue_delete_ex(queue_);
        }
    }
 
    [[nodiscard]] bool IsValid() const noexcept { return created_; }
 
    bool Send(const MessageType& message, uint32_t timeout_ms = UINT32_MAX) noexcept
    {
        if (!created_) return false;
        uint32_t item[kItemWords] = {};
        std::memcpy(item, &message, sizeof(MessageType));
        return os_queue_send_ex(queue_, item, ToTicks(timeout_ms));
    }
 
    bool Receive(MessageType& out, uint32_t timeout_ms = UINT32_MAX) noexcept
    {
        if (!created_) return false;
        uint32_t item[kItemWords] = {};
        if (!os_queue_receive_ex(queue_, item, ToTicks(timeout_ms))) return false;
        std::memcpy(&out, item, sizeof(MessageType));
        return true;
    }
 
    [[nodiscard]] static constexpr size_t Capacity() noexcept { return kCapacity; }
 
private:
    static constexpr size_t kItemWords = (sizeof(MessageType) + sizeof(uint32_t) - 1U) / sizeof(uint32_t);
    static constexpr size_t kStoreBytes =
        (OS_QUEUE_STORE_BYTES(kItemWords, kCapacity) > 0U) ? OS_QUEUE_STORE_BYTES(kItemWords, kCapacity) : 1U;
 
    static OS_Ulong ToTicks(uint32_t timeout_ms) noexcept
    {
        return (timeout_ms == UINT32_MAX)
            ? static_cast<OS_Ulong>(OS_WAIT_FOREVER)
            : static_cast<OS_Ulong>(os_convert_msec_to_delay_ticks(timeout_ms));
    }
 
    const char* name_;
    bool        created_{false};
    OS_Queue    queue_{};
    alignas(std::max_align_t) uint8_t storage_[kStoreBytes];
};
 
#endif /* OS_QUEUE_H_ */