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/utility.hpp"
#include "../macros.hpp"
#include <type_traits>
#include <memory>
#include <initializer_list>
#include <stdexcept>
#include <array>
 
hi_export_module(hikogui.container.stack);
 
hi_export namespace hi::inline v1 {
 
template<typename T, std::size_t MaxSize>
class stack {
public:
    using value_type = T;
    using array_type = std::array<value_type, MaxSize>;
    using pointer = array_type::pointer;
    using const_pointer = array_type::const_pointer;
    using reference = array_type::reference;
    using const_reference = array_type::const_reference;
    using iterator = array_type::iterator;
    using const_iterator = array_type::const_iterator;
    using size_type = array_type::size_type;
    using difference_type = array_type::difference_type;
 
    constexpr ~stack() noexcept = default;
    stack(stack const&) = delete;
    stack(stack&&) = delete;
    stack& operator=(stack const&) = delete;
    stack& operator=(stack&&) = delete;
 
    constexpr stack() noexcept
    {
        _top = _data.begin();
    }
 
    [[nodiscard]] constexpr const_pointer data() const noexcept
    {
        return _data.data();
    }
 
    [[nodiscard]] constexpr pointer data() noexcept
    {
        return _data.data();
    }
 
    [[nodiscard]] constexpr iterator begin() noexcept
    {
        return _data.begin();
    }
 
    [[nodiscard]] constexpr const_iterator begin() const noexcept
    {
        return _data.begin();
    }
 
    [[nodiscard]] constexpr const_iterator cbegin() const noexcept
    {
        return _data.cbegin();
    }
 
    [[nodiscard]] constexpr iterator end() noexcept
    {
        return _top;
    }
 
    [[nodiscard]] constexpr const_iterator end() const noexcept
    {
        return _top;
    }
 
    [[nodiscard]] constexpr const_iterator cend() const noexcept
    {
        return _top;
    }
 
    [[nodiscard]] constexpr size_type max_size() const noexcept
    {
        return MaxSize;
    }
 
    [[nodiscard]] constexpr size_type size() const noexcept
    {
        return narrow_cast<size_type>(std::distance(begin(), end()));
    }
 
    [[nodiscard]] constexpr bool full() const noexcept
    {
        return _top == _data.end();
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return _top == _data.begin();
    }
 
    [[nodiscard]] constexpr reference operator[](std::size_t index) noexcept
    {
        hi_axiom_bounds(index, *this);
        return _data[index];
    }
 
    [[nodiscard]] constexpr const_reference operator[](std::size_t index) const noexcept
    {
        hi_axiom_bounds(index, *this);
        return _data[index];
    }
 
    [[nodiscard]] constexpr reference at(std::size_t index) noexcept
    {
        if (index >= size()) {
            throw std::out_of_range("stack::at");
        }
        return _data[index];
    }
 
    [[nodiscard]] constexpr const_reference at(std::size_t index) const noexcept
    {
        if (index >= size()) {
            throw std::out_of_range("stack::at");
        }
        return _data[index];
    }
 
    [[nodiscard]] constexpr reference back() noexcept
    {
        hi_axiom(not empty());
        return *(_top - 1);
    }
 
    [[nodiscard]] constexpr const_reference back() const noexcept
    {
        hi_axiom(not empty());
        return *(_top - 1);
    }
 
    template<typename... Args>
    constexpr void emplace_back(Args&&...args) noexcept
    {
        hi_axiom(not full());
        *(_top++) = value_type(std::forward<Args>(args)...);
    }
 
    template<typename Arg>
    constexpr void push_back(Arg&& arg) noexcept
        requires(std::is_convertible_v<Arg, value_type>)
    {
        hi_axiom(not full());
        *(_top++) = std::forward<Arg>(arg);
    }
 
    constexpr void pop_back() noexcept
    {
        hi_axiom(not empty());
        --_top;
    }
 
    constexpr void pop_back(const_iterator new_end) noexcept
    {
        while (_top != new_end) {
            pop_back();
        }
    }
 
    constexpr void clear() noexcept
    {
        _top = _data.begin();
    }
 
private:
    array_type _data;
    array_type::iterator _top;
};
 
} // namespace hi::inline v1