storage.hpp

Go to the documentation of this file.

// Copyright (C) 2020-2025 Andrei Avram
 
#ifndef MSD_CHANNEL_STORAGE_HPP_
#define MSD_CHANNEL_STORAGE_HPP_
 
#include "nodiscard.hpp"
 
#include <array>
#include <cstdlib>
#include <queue>
#include <vector>
 
namespace msd {
 
template <typename T>
class queue_storage {
   public:
    explicit queue_storage(std::size_t) {}
 
    template <typename Type>
    void push_back(Type&& value)
    {
        queue_.push(std::forward<Type>(value));
    }
 
    void pop_front(T& out)
    {
        out = std::move(queue_.front());
        queue_.pop();
    }
 
    NODISCARD std::size_t size() const noexcept { return queue_.size(); }
 
   private:
    std::queue<T> queue_;
};
 
template <typename T>
class vector_storage {
   public:
    explicit vector_storage(std::size_t capacity) { vector_.reserve(capacity); }
 
    template <typename Type>
    void push_back(Type&& value)
    {
        vector_.push_back(std::forward<Type>(value));
    }
 
    void pop_front(T& out)
    {
        out = std::move(vector_.front());
        vector_.erase(vector_.begin());
    }
 
    NODISCARD std::size_t size() const noexcept { return vector_.size(); }
 
   private:
    std::vector<T> vector_;
};
 
template <typename T, std::size_t N>
class array_storage {
   public:
    static_assert(N > 0, "Capacity must be greater than zero.");
 
    static constexpr std::size_t capacity = N;
 
    template <typename Type>
    void push_back(Type&& value)
    {
        array_[(front_ + size_) % N] = std::forward<Type>(value);
        ++size_;
    }
 
    void pop_front(T& out)
    {
        out = std::move(array_[front_]);
        front_ = (front_ + 1) % N;
        --size_;
    }
 
    NODISCARD std::size_t size() const noexcept { return size_; }
 
   private:
    std::array<T, N> array_{};
    std::size_t size_{0};
    std::size_t front_{0};
};
 
template <typename T, std::size_t N>
constexpr std::size_t array_storage<T, N>::capacity;
 
}  // namespace msd
 
#endif  // MSD_CHANNEL_STORAGE_HPP_