queue.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_FREERTOS_QUEUE_HPP
#define TETL_FREERTOS_QUEUE_HPP
 
#include <etl/version.hpp>
 
#include <etl/cstdint.hpp>
#include <etl/utility.hpp>
 
#if defined(TETL_FREERTOS_USE_STUBS)
    #include <etl/experimental/freertos/stubs.hpp>
#endif
 
namespace etl::experimental::freertos {

template <typename T, etl::uint32_t Size>
struct queue {
    using value_type = T;
    using size_type  = etl::uint32_t;

    queue();

    ~queue();
 
    queue(queue const&)                    = delete;
    auto operator=(queue const&) -> queue& = delete;
 
    queue(queue&&)                    = delete;
    auto operator=(queue&&) -> queue& = delete;

    [[nodiscard]] auto capacity() const -> size_type;

    [[nodiscard]] auto send(T const& data, TickType_t ticksToWait = 0) const -> bool;

    auto receive(T& data, TickType_t ticksToWait = 0) const -> bool;

    [[nodiscard]] auto receive(TickType_t ticksToWait = 0) const -> pair<bool, T>;
 
    [[nodiscard]] auto reset() const -> bool;
    [[nodiscard]] auto messages_waiting() const -> etl::uint32_t;
 
private:
    QueueHandle_t _handle = nullptr;
};
 
template <typename T, etl::uint32_t Size>
inline queue<T, Size>::queue()
    : _handle{[]() { return xQueueCreate(Size, sizeof(T)); }()}
{
}
 
template <typename T, etl::uint32_t Size>
inline queue<T, Size>::~queue()
{
    if (_handle != nullptr) {
        vQueueDelete(_handle);
    }
}
 
template <typename T, etl::uint32_t Size>
inline auto queue<T, Size>::capacity() const -> size_type
{
    return Size;
}
 
template <typename T, etl::uint32_t Size>
inline auto queue<T, Size>::send(T const& data, TickType_t ticksToWait) const -> bool
{
    auto const* const rawData = static_cast<void const*>(&data);
    auto const success        = xQueueSend(_handle, rawData, ticksToWait);
    return static_cast<bool>(success);
}
 
template <typename T, etl::uint32_t Size>
inline auto queue<T, Size>::receive(T& data, TickType_t ticksToWait) const -> bool
{
    auto* const rawData = static_cast<void*>(&data);
    auto const success  = xQueueReceive(_handle, rawData, ticksToWait);
    return static_cast<bool>(success);
}
 
template <typename T, etl::uint32_t Size>
inline auto queue<T, Size>::receive(TickType_t ticksToWait) const -> pair<bool, T>
{
    auto value          = T{};
    auto* const rawData = static_cast<void*>(&value);
    auto const success  = xQueueReceive(_handle, rawData, ticksToWait);
    return {static_cast<bool>(success), value};
}
 
template <typename T, etl::uint32_t Size>
inline auto queue<T, Size>::reset() const -> bool
{
    auto const result = xQueueReset(_handle);
    return static_cast<bool>(result);
}
 
template <typename T, etl::uint32_t Size>
inline auto queue<T, Size>::messages_waiting() const -> etl::uint32_t
{
    auto const result = uxQueueMessagesWaiting(_handle);
    return static_cast<etl::uint32_t>(result);
}
} // namespace etl::experimental::freertos
 
#endif // TETL_FREERTOS_QUEUE_HPP