stream.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#ifdef CONFIG_OVE_STREAM
 
#include <ove/stream.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
 
namespace ove
{
 
template <size_t BufSize = 0> class Stream
{
      public:
    explicit Stream(size_t trigger)
        requires(BufSize > 0)
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        static_assert(BufSize > 0, "BufSize must be > 0 in zero-heap mode");
        int err = ove_stream_init(&handle_, &storage_, buffer_, BufSize, trigger);
#else
        int err = ove_stream_create(&handle_, BufSize, trigger);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Stream() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_stream_deinit(handle_);
#else
        ove_stream_destroy(handle_);
#endif
    }
 
    Stream(const Stream &) = delete;
    Stream &operator=(const Stream &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    Stream(Stream &&) = delete;
    Stream &operator=(Stream &&) = delete;
#else
    Stream(Stream &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    Stream &operator=(Stream &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_stream_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    void send(const void *data, size_t len, size_t &bytes_sent)
    {
        const int err = ove_stream_send(handle_, data, len, OVE_WAIT_FOREVER, &bytes_sent);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    [[nodiscard]] bool try_send(const void *data, size_t len, size_t &bytes_sent)
    {
        return ove_stream_send(handle_, data, len, 0, &bytes_sent) == OVE_OK;
    }
 
    template <class Rep, class Period>
    [[nodiscard]] Result<void> try_send_for(const void *data, size_t len,
                        const std::chrono::duration<Rep, Period> &rel,
                        size_t &bytes_sent) noexcept
    {
        return from_rc(
            ove_stream_send(handle_, data, len, to_timeout_ns(rel), &bytes_sent));
    }
 
    template <class Clock, class Duration>
    [[nodiscard]] Result<void>
    try_send_until(const void *data, size_t len,
               const std::chrono::time_point<Clock, Duration> &deadline,
               size_t &bytes_sent) noexcept
    {
        const auto rel = deadline - Clock::now();
        return from_rc(
            ove_stream_send(handle_, data, len, to_timeout_ns(rel), &bytes_sent));
    }
 
    void receive(void *buf, size_t len, size_t &bytes_received)
    {
        const int err =
            ove_stream_receive(handle_, buf, len, OVE_WAIT_FOREVER, &bytes_received);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    [[nodiscard]] bool try_receive(void *buf, size_t len, size_t &bytes_received)
    {
        return ove_stream_receive(handle_, buf, len, 0, &bytes_received) == OVE_OK;
    }
 
    template <class Rep, class Period>
    [[nodiscard]] Result<void> try_receive_for(void *buf, size_t len,
                           const std::chrono::duration<Rep, Period> &rel,
                           size_t &bytes_received) noexcept
    {
        return from_rc(
            ove_stream_receive(handle_, buf, len, to_timeout_ns(rel), &bytes_received));
    }
 
    template <class Clock, class Duration>
    [[nodiscard]] Result<void>
    try_receive_until(void *buf, size_t len,
              const std::chrono::time_point<Clock, Duration> &deadline,
              size_t &bytes_received) noexcept
    {
        const auto rel = deadline - Clock::now();
        return from_rc(
            ove_stream_receive(handle_, buf, len, to_timeout_ns(rel), &bytes_received));
    }
 
    [[nodiscard]] Result<void> send_from_isr(const void *data, size_t len,
                         size_t &bytes_sent) noexcept
    {
        return from_rc(ove_stream_send_from_isr(handle_, data, len, &bytes_sent));
    }
 
    [[nodiscard]] Result<void> receive_from_isr(void *buf, size_t len,
                            size_t &bytes_received) noexcept
    {
        return from_rc(ove_stream_receive_from_isr(handle_, buf, len, &bytes_received));
    }
 
    [[nodiscard]] Result<void> reset() noexcept
    {
        return from_rc(ove_stream_reset(handle_));
    }
 
    size_t bytes_available() const
    {
        return ove_stream_bytes_available(handle_);
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_stream_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_stream_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_stream_storage_t storage_ = {};
    uint8_t buffer_[(BufSize > 0 ? BufSize : 1) + 1];
#endif
};
 
} /* namespace ove */
 
#endif /* CONFIG_OVE_STREAM */