containers.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <stdexcept>
#include <string>
#include <variant>
#include <vector>

 
namespace containers {
 
// ─── Exceptions ──────────────────────────────────────────────────────────────

class ContainerError : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};

class BufferOverflow : public ContainerError {
public:
    BufferOverflow() : ContainerError("buffer overflow: container is full") {}
};

class BufferUnderflow : public ContainerError {
public:
    BufferUnderflow() : ContainerError("buffer underflow: container is empty") {}
};
 
// ─── Stack ───────────────────────────────────────────────────────────────────

template <typename T>
class Stack {
public:
    void push(const T& value) {
        data_.push_back(value);
    }

    T pop() {
        if (data_.empty()) throw BufferUnderflow();
        T val = data_.back();
        data_.pop_back();
        return val;
    }

    [[nodiscard]] const T& top() const {
        if (data_.empty()) throw BufferUnderflow();
        return data_.back();
    }

    [[nodiscard]] bool empty() const { return data_.empty(); }

    [[nodiscard]] std::size_t size() const { return data_.size(); }

    void clear() { data_.clear(); }
 
private:
    std::vector<T> data_; 
};
 
// ─── RingBuffer ──────────────────────────────────────────────────────────────

template <typename T, std::size_t N>
class RingBuffer {
public:
    RingBuffer() = default;

    void write(const T& value) {
        if (full()) throw BufferOverflow();
        buf_[tail_] = value;
        tail_ = (tail_ + 1) % N;
        ++size_;
    }

    T read() {
        if (empty()) throw BufferUnderflow();
        T val = buf_[head_];
        head_ = (head_ + 1) % N;
        --size_;
        return val;
    }

    [[nodiscard]] bool empty() const { return size_ == 0; }

    [[nodiscard]] bool full() const { return size_ == N; }

    [[nodiscard]] std::size_t size() const { return size_; }

    [[nodiscard]] constexpr std::size_t capacity() const { return N; }
 
private:
    std::array<T, N> buf_{}; 
    std::size_t head_ = 0;   
    std::size_t tail_ = 0;   
    std::size_t size_ = 0;   
};
 
// ─── Result ──────────────────────────────────────────────────────────────────

template <typename T, typename E = std::string>
class Result {
public:
    static Result ok(T value) { return Result(std::move(value)); }

    static Result err(E error) { return Result(ErrTag{}, std::move(error)); }

    [[nodiscard]] bool is_ok() const {
        return std::holds_alternative<T>(data_);
    }

    [[nodiscard]] bool is_err() const { return !is_ok(); }

    [[nodiscard]] const T& value() const { return std::get<T>(data_); }

    [[nodiscard]] const E& error() const { return std::get<E>(data_); }
 
private:
    struct ErrTag {};
    explicit Result(T value) : data_(std::move(value)) {}
    Result(ErrTag, E error) : data_(std::move(error)) {}
 
    std::variant<T, E> data_; 
};
 
} // namespace containers
 // end of containers group