stack.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_STACK_STACK_HPP
#define TETL_STACK_STACK_HPP
 
#include <etl/_iterator/begin.hpp>
#include <etl/_iterator/data.hpp>
#include <etl/_iterator/end.hpp>
#include <etl/_iterator/rbegin.hpp>
#include <etl/_iterator/rend.hpp>
#include <etl/_iterator/size.hpp>
#include <etl/_type_traits/declval.hpp>
#include <etl/_type_traits/is_nothrow_swappable.hpp>
#include <etl/_type_traits/is_swappable.hpp>
#include <etl/_utility/forward.hpp>
#include <etl/_utility/move.hpp>
 
namespace etl {

template <typename T, typename Container>
struct stack {
    using value_type      = typename Container::value_type;
    using reference       = typename Container::reference;
    using const_reference = typename Container::const_reference;
    using size_type       = typename Container::size_type;
    using container_type  = Container;

    constexpr stack()
        : stack{Container{}}
    {
    }

    constexpr explicit stack(Container const& cont)
        : c{cont}
    {
    }

    constexpr explicit stack(Container&& cont)
        : c{etl::move(cont)}
    {
    }

    constexpr stack(stack const& other) = default;

    constexpr stack(stack&& other) noexcept = default;

    [[nodiscard]] constexpr auto empty() const noexcept(noexcept(declval<Container>().empty())) -> bool
    {
        return c.empty();
    }

    [[nodiscard]] constexpr auto size() const noexcept(noexcept(declval<Container>().size())) -> size_type
    {
        return c.size();
    }

    [[nodiscard]] constexpr auto top() noexcept(noexcept(declval<Container>().back())) -> reference { return c.back(); }

    [[nodiscard]] constexpr auto top() const noexcept(noexcept(declval<Container>().back())) -> const_reference
    {
        return c.back();
    }

    constexpr auto push(value_type const& x) noexcept(noexcept(declval<Container>().push_back(x))) -> void
    {
        c.push_back(x);
    }

    constexpr auto push(value_type&& x) noexcept(noexcept(declval<Container>().push_back(etl::move(x)))) -> void
    {
        c.push_back(etl::move(x));
    }

    template <typename... Args>
    constexpr auto emplace(Args&&... args)
        noexcept(noexcept(declval<Container>().emplace_back(etl::forward<Args>(args)...))) -> decltype(auto)
    {
        return c.emplace_back(etl::forward<Args>(args)...);
    }

    constexpr auto pop() noexcept(noexcept(declval<Container>().pop_back())) -> void { c.pop_back(); }

    constexpr auto swap(stack& s) noexcept(is_nothrow_swappable_v<Container>) -> void
    {
        using etl::swap;
        swap(c, s.c);
    }

    [[nodiscard]] friend constexpr auto operator==(stack const& lhs, stack const& rhs)
        noexcept(noexcept(lhs.c == rhs.c)) -> bool
    {
        return lhs.c == rhs.c;
    }

    [[nodiscard]] friend constexpr auto operator!=(stack const& lhs, stack const& rhs)
        noexcept(noexcept(lhs.c != rhs.c)) -> bool
    {
        return lhs.c != rhs.c;
    }

    [[nodiscard]] friend constexpr auto operator<(stack const& lhs, stack const& rhs) noexcept(noexcept(lhs.c < rhs.c))
        -> bool
    {
        return lhs.c < rhs.c;
    }

    [[nodiscard]] friend constexpr auto operator<=(stack const& lhs, stack const& rhs)
        noexcept(noexcept(lhs.c <= rhs.c)) -> bool
    {
        return lhs.c <= rhs.c;
    }

    [[nodiscard]] friend constexpr auto operator>(stack const& lhs, stack const& rhs) noexcept(noexcept(lhs.c > rhs.c))
        -> bool
    {
        return lhs.c > rhs.c;
    }

    [[nodiscard]] friend constexpr auto operator>=(stack const& lhs, stack const& rhs)
        noexcept(noexcept(lhs.c >= rhs.c)) -> bool
    {
        return lhs.c >= rhs.c;
    }
 
protected:
    Container c;
};
 
// These deduction guides are provided for stack to allow deduction from
// underlying container type.
template <typename Container>
stack(Container) -> stack<typename Container::value_type, Container>;

template <typename T, typename C>
    requires(is_swappable_v<C>)
constexpr auto swap(stack<T, C>& lhs, stack<T, C>& rhs) noexcept(noexcept(lhs.swap(rhs))) -> void
{
    lhs.swap(rhs);
}
 
} // namespace etl
 
#endif // TETL_STACK_STACK_HPP