static_ring.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#include <array>
#include <cstddef>
#include <type_traits>
#include <utility>
 
#include "tsm/runtime/policy.h"
 
namespace tsm::runtime::storage {
 
template<typename Event, std::size_t Capacity>
class fixed_ring_queue
{
    static_assert(Capacity > 1,
                  "tsm: fixed_ring_queue needs at least two slots");
 
  public:
    using value_type = Event;
    static constexpr std::size_t capacity = Capacity;
 
    [[nodiscard]] bool try_push(Event const& event)
    {
        if (full()) {
            return false;
        }
        data_[push_index_] = event;
        push_index_ = next(push_index_);
        ++size_;
        return true;
    }
 
    [[nodiscard]] bool try_push(Event&& event)
    {
        if (full()) {
            return false;
        }
        data_[push_index_] = std::move(event);
        push_index_ = next(push_index_);
        ++size_;
        return true;
    }
 
    [[nodiscard]] bool try_pop(Event& event)
    {
        if (empty()) {
            return false;
        }
        event = std::move(data_[pop_index_]);
        pop_index_ = next(pop_index_);
        --size_;
        return true;
    }
 
    template<typename Value>
    [[nodiscard]] bool try_overwrite_latest(Value&& event)
    {
        if (empty()) {
            return false;
        }
        data_[previous(push_index_)] = std::forward<Value>(event);
        return true;
    }
 
    [[nodiscard]] bool empty() const
    {
        return size_ == 0;
    }
    [[nodiscard]] bool full() const
    {
        return size_ == Capacity;
    }
    [[nodiscard]] std::size_t size() const
    {
        return size_;
    }
 
    void clear()
    {
        push_index_ = 0;
        pop_index_ = 0;
        size_ = 0;
    }
 
  private:
    static constexpr std::size_t next(std::size_t index)
    {
        return (index + 1U) % Capacity;
    }
 
    static constexpr std::size_t previous(std::size_t index)
    {
        return index == 0U ? Capacity - 1U : index - 1U;
    }
 
    std::array<Event, Capacity> data_{};
    std::size_t push_index_{};
    std::size_t pop_index_{};
    std::size_t size_{};
};
 
template<std::size_t Capacity>
struct static_ring
{
    static constexpr std::size_t capacity = Capacity;
 
    template<typename Event>
    using queue = fixed_ring_queue<Event, Capacity>;
};
 
struct static_storage_tag
{};
struct freertos_storage_tag
{};
struct zephyr_storage_tag
{};
 
#if defined(__FREE_RTOS__)
using active_storage_tag = freertos_storage_tag;
#elif defined(__ZEPHYR__)
using active_storage_tag = zephyr_storage_tag;
#else
using active_storage_tag = static_storage_tag;
#endif
 
template<std::size_t Capacity, typename StorageTag = active_storage_tag>
struct target_storage;
 
template<std::size_t Capacity>
struct target_storage<Capacity, static_storage_tag>
{
    using type = static_ring<Capacity>;
};
 
template<std::size_t Capacity>
using target_queue = typename target_storage<Capacity>::type;
 
} // namespace tsm::runtime::storage
 
namespace tsm {
 
template<std::size_t Capacity>
using static_storage = runtime::storage::static_ring<Capacity>;
 
template<std::size_t Capacity>
using target_storage = runtime::storage::target_queue<Capacity>;
 
template<typename T,
         typename StoragePolicy,
         typename OverflowPolicy = overflow::reject_newest>
class queue
{
    static_assert(runtime::queue_storage_policy<StoragePolicy, T>,
                  "tsm: queue requires a storage policy for T");
    static_assert(overflow_policy<OverflowPolicy>,
                  "tsm: queue requires a known overflow policy");
 
    using storage_type = typename StoragePolicy::template queue<T>;
 
  public:
    using value_type = T;
    using storage_policy = StoragePolicy;
    using overflow_policy = OverflowPolicy;
 
    [[nodiscard]] bool try_push(T const& value)
    {
        return push(value);
    }
 
    [[nodiscard]] bool try_push(T&& value)
    {
        return push(std::move(value));
    }
 
    [[nodiscard]] bool try_pop(T& value)
    {
        return storage_.try_pop(value);
    }
 
    [[nodiscard]] bool empty() const
    {
        return storage_.empty();
    }
    [[nodiscard]] bool full() const
    {
        return storage_.full();
    }
    [[nodiscard]] std::size_t size() const
    {
        return storage_.size();
    }
 
  private:
    template<typename Value>
    [[nodiscard]] bool push(Value&& value)
    {
        if constexpr (std::same_as<OverflowPolicy, overflow::reject_newest>) {
            return storage_.try_push(std::forward<Value>(value));
        } else if constexpr (std::same_as<OverflowPolicy,
                                          overflow::drop_oldest>) {
            if (storage_.try_push(std::forward<Value>(value))) {
                return true;
            }
            T discarded{};
            if (!storage_.try_pop(discarded)) {
                return false;
            }
            return storage_.try_push(std::forward<Value>(value));
        } else {
            if (storage_.try_push(std::forward<Value>(value))) {
                return true;
            }
            return storage_.try_overwrite_latest(std::forward<Value>(value));
        }
    }
 
    storage_type storage_{};
};
 
} // namespace tsm