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 <type_traits>
#include <memory>
#include <initializer_list>
#include "utility/module.hpp"
 
namespace hi::inline v1 {
 
template<typename T, std::size_t MaxSize>
class stack {
public:
    using value_type = T;
    using pointer_type = value_type *;
    using const_pointer_type = value_type const *;
    using reference_type = value_type &;
    using const_reference_type = value_type const &;
    using iterator_type = pointer_type;
    using const_iterator_type = const_pointer_type;
    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]] iterator_type begin() noexcept
    {
        return std::launder(reinterpret_cast<pointer_type>(&_buffer[0]));
    }
 
    [[nodiscard]] const_iterator_type begin() const noexcept
    {
        return std::launder(reinterpret_cast<const_pointer_type>(&_buffer[0]));
    }
 
    [[nodiscard]] const_iterator_type cbegin() const noexcept
    {
        return std::launder(reinterpret_cast<const_pointer_type>(&_buffer[0]));
    }
 
    [[nodiscard]] iterator_type end() noexcept
    {
        return _top;
    }
 
    [[nodiscard]] const_iterator_type end() const noexcept
    {
        return _top;
    }
 
    [[nodiscard]] const_iterator_type 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>(end() - begin());
    }
 
    [[nodiscard]] bool full() const noexcept
    {
        return _top == (begin() + max_size());
    }
 
    [[nodiscard]] bool empty() const noexcept
    {
        return _top == begin();
    }
 
    [[nodiscard]] reference_type operator[](std::size_t index) noexcept
    {
        hi_assert_bounds(index, *this);
        return *std::launder(reinterpret_cast<pointer_type>(&_buffer[index]));
    }
 
    [[nodiscard]] const_reference_type operator[](std::size_t index) const noexcept
    {
        hi_assert_bounds(index, *this);
        return *std::launder(reinterpret_cast<pointer_type>(&_buffer[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(!empty());
        return *std::launder(_top - 1);
    }
 
    [[nodiscard]] const_reference_type back() const noexcept
    {
        hi_axiom(!empty());
        return *std::launder(_top - 1);
    }
 
    template<typename... Args>
    void emplace_back(Args &&...args) noexcept
    {
        hi_axiom(!full());
        new (end()) value_type(std::forward<Args>(args)...);
        ++_top;
    }
 
    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(!empty());
        auto *old_item = std::launder(--_top);
        std::destroy_at(old_item);
    }
 
    void pop_back(iterator_type new_end) noexcept
    {
        while (_top != new_end) {
            pop_back();
        }
    }
 
    void clear() noexcept
    {
        std::destroy(begin(), end());
        _top = begin();
    }
 
private:
    std::aligned_storage_t<sizeof(T), std::alignment_of_v<T>> _buffer[MaxSize];
    pointer_type _top;
};
 
} // namespace hi::inline v1