stack.hpp

// Copyright Take Vos 2020-2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../utility/module.hpp"
#include <type_traits>
#include <memory>
#include <initializer_list>
 
namespace hi::inline v1 {
 
template<typename T, std::size_t MaxSize>
class stack {
public:
    using value_type = T;
    using pointer = value_type *;
    using const_pointer = value_type const *;
    using reference_type = value_type &;
    using const_reference_type = value_type const &;
    using iterator = pointer;
    using const_iterator = const_pointer;
    using size_type = std::size_t;
    using difference_type = ptrdiff_t;
 
    stack() noexcept : _top(begin()) {}
 
    stack(std::initializer_list<value_type> init) noexcept : _top(begin())
    {
        for (hilet &init_item : init) {
            push_back(init_item);
        }
    }
 
    ~stack() noexcept
    {
        clear();
    }
 
    [[nodiscard]] const_pointer data() const noexcept
    {
        return reinterpret_cast<const_pointer>(_buffer);
    }
 
    [[nodiscard]] pointer data() noexcept
    {
        return reinterpret_cast<pointer>(_buffer);
    }
 
    [[nodiscard]] iterator begin() noexcept
    {
        return data();
    }
 
    [[nodiscard]] const_iterator begin() const noexcept
    {
        return data();
    }
 
    [[nodiscard]] const_iterator cbegin() const noexcept
    {
        return data();
    }
 
    [[nodiscard]] iterator end() noexcept
    {
        return _top;
    }
 
    [[nodiscard]] const_iterator end() const noexcept
    {
        return _top;
    }
 
    [[nodiscard]] const_iterator cend() const noexcept
    {
        return _top;
    }
 
    [[nodiscard]] constexpr size_type max_size() const noexcept
    {
        return MaxSize;
    }
 
    [[nodiscard]] size_type size() const noexcept
    {
        return narrow_cast<size_type>(std::distance(begin(), end()));
    }
 
    [[nodiscard]] bool full() const noexcept
    {
        return _top == (data() + max_size());
    }
 
    [[nodiscard]] bool empty() const noexcept
    {
        return _top == data();
    }
 
    [[nodiscard]] reference_type operator[](std::size_t index) noexcept
    {
        hi_assert_bounds(index, *this);
        return *(data() + index);
    }
 
    [[nodiscard]] const_reference_type operator[](std::size_t index) const noexcept
    {
        hi_assert_bounds(index, *this);
        return *(data() + index);
    }
 
    [[nodiscard]] reference_type at(std::size_t index) noexcept
    {
        if (index >= size()) {
            throw std::out_of_range("stack::at");
        }
        return (*this)[index];
    }
 
    [[nodiscard]] const_reference_type at(std::size_t index) const noexcept
    {
        if (index >= size()) {
            throw std::out_of_range("stack::at");
        }
        return (*this)[index];
    }
 
    [[nodiscard]] reference_type back() noexcept
    {
        hi_axiom(not empty());
        return *(_top - 1);
    }
 
    [[nodiscard]] const_reference_type back() const noexcept
    {
        hi_axiom(not empty());
        return *(_top - 1);
    }
 
    template<typename... Args>
    void emplace_back(Args &&...args) noexcept
    {
        hi_axiom(not full());
        new (_top++) value_type(std::forward<Args>(args)...);
    }
 
    template<typename Arg>
    requires(std::is_convertible_v<Arg, value_type>) void push_back(Arg &&arg) noexcept
    {
        emplace_back(std::forward<Arg>(arg));
    }
 
    void pop_back() noexcept
    {
        hi_axiom(not empty());
        std::destroy_at(--_top);
    }
 
    void pop_back(iterator new_end) noexcept
    {
        while (_top != new_end) {
            pop_back();
        }
    }
 
    void clear() noexcept
    {
        std::destroy(data(), _top);
        _top = data();
    }
 
private:
    pointer _top;
    alignas(T) std::byte _buffer[MaxSize * sizeof(T)];
};
 
} // namespace hi::inline v1