stream_buffer.hpp

Go to the documentation of this file.

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

struct stream_buffer {
    using size_type = etl::size_t;

    stream_buffer(size_type size, size_type triggerLevel) noexcept;

    ~stream_buffer() noexcept;
 
    stream_buffer(stream_buffer const& other)                    = delete;
    auto operator=(stream_buffer const& other) -> stream_buffer& = delete;
 
    stream_buffer(stream_buffer&& other)                    = delete;
    auto operator=(stream_buffer&& other) -> stream_buffer& = delete;

    auto write(net::const_buffer data, TickType_t ticks) -> size_type;

    auto write_from_isr(net::const_buffer data, BaseType_t* prio) -> size_type;

    auto read(net::mutable_buffer data, TickType_t ticks) -> size_type;

    auto read_from_isr(net::mutable_buffer data, BaseType_t* prio) -> size_type;

    [[nodiscard]] auto empty() const noexcept -> bool;

    [[nodiscard]] auto full() const noexcept -> bool;

    [[nodiscard]] auto bytes_available() const noexcept -> size_type;

    [[nodiscard]] auto space_available() const noexcept -> size_type;

    auto reset() noexcept -> void;

    auto trigger_level(size_type triggerLevel) noexcept -> void;

    [[nodiscard]] auto native_handle() const noexcept -> StreamBufferHandle_t;
 
private:
    StreamBufferHandle_t _handle;
};
 
inline stream_buffer::stream_buffer(size_t size, size_t triggerLevel) noexcept
    : _handle{xStreamBufferCreate(size, triggerLevel)}
{
}
 
inline stream_buffer::~stream_buffer() noexcept { vStreamBufferDelete(_handle); }
 
inline auto stream_buffer::write(net::const_buffer data, TickType_t ticks) -> size_t
{
    return xStreamBufferSend(_handle, data.data(), data.size(), ticks);
}
 
inline auto stream_buffer::write_from_isr(net::const_buffer data, BaseType_t* prio) -> size_t
{
    return xStreamBufferSendFromISR(_handle, data.data(), data.size(), prio);
}
 
inline auto stream_buffer::read(net::mutable_buffer data, TickType_t ticks) -> size_t
{
    return xStreamBufferReceive(_handle, data.data(), data.size(), ticks);
}
 
inline auto stream_buffer::read_from_isr(net::mutable_buffer data, BaseType_t* prio) -> size_t
{
    return xStreamBufferReceiveFromISR(_handle, data.data(), data.size(), prio);
}
 
inline auto stream_buffer::empty() const noexcept -> bool { return static_cast<bool>(xStreamBufferIsEmpty(_handle)); }
 
inline auto stream_buffer::full() const noexcept -> bool { return static_cast<bool>(xStreamBufferIsFull(_handle)); }
 
inline auto stream_buffer::bytes_available() const noexcept -> size_type
{
    return xStreamBufferBytesAvailable(_handle);
}
 
inline auto stream_buffer::space_available() const noexcept -> size_type
{
    return xStreamBufferSpacesAvailable(_handle);
}
 
inline auto stream_buffer::reset() noexcept -> void { xStreamBufferReset(_handle); }
 
inline auto stream_buffer::trigger_level(size_type triggerLevel) noexcept -> void
{
    xStreamBufferSetTriggerLevel(_handle, triggerLevel);
}
 
inline auto stream_buffer::native_handle() const noexcept -> StreamBufferHandle_t { return _handle; }
 
} // namespace etl::experimental::freertos
 
#endif // TETL_FREERTOS_STREAM_BUFFER_HPP