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>
 
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() {
        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
 
    [[nodiscard]] int send(const void *data, size_t len,
                uint32_t timeout_ms, size_t *bytes_sent) {
        return ove_stream_send(handle_, data, len, timeout_ms,
                        bytes_sent);
    }
 
    [[nodiscard]] int receive(void *buf, size_t len,
                   uint32_t timeout_ms,
                   size_t *bytes_received) {
        return ove_stream_receive(handle_, buf, len, timeout_ms,
                           bytes_received);
    }
 
    [[nodiscard]] int send_from_isr(const void *data, size_t len,
                     size_t *bytes_sent) {
        return ove_stream_send_from_isr(handle_, data, len,
                             bytes_sent);
    }
 
    [[nodiscard]] int receive_from_isr(void *buf, size_t len,
                        size_t *bytes_received) {
        return ove_stream_receive_from_isr(handle_, buf, len,
                               bytes_received);
    }
 
    [[nodiscard]] int reset() {
        return 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 */