stack.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_CONTAINER_STACK_HPP__
#define NEFORCE_CORE_CONTAINER_STACK_HPP__

 
#include "NeForce/core/container/deque.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename T, typename Sequence = deque<T>>
class stack : public icollector<stack<T, Sequence>> {
    static_assert(is_object_v<T>, "stack only contains object types.");
    static_assert(is_same_v<T, typename Sequence::value_type>, "stack require consistent types.");
 
public:
    using value_type = typename Sequence::value_type;           
    using difference_type = typename Sequence::difference_type; 
    using size_type = typename Sequence::size_type;             
    using reference = typename Sequence::reference;             
    using const_reference = typename Sequence::const_reference; 
 
private:
    Sequence seq_{}; 
 
public:
    stack() = default;
    ~stack() = default;
 
    stack(const stack&) = default;
    stack& operator=(const stack&) = default;
    stack(stack&&) noexcept(is_nothrow_move_constructible_v<Sequence>) = default;
    stack& operator=(stack&&) noexcept(is_nothrow_move_assignable_v<Sequence>) = default;

    explicit stack(const Sequence& seq) :
    seq_(seq) {}

    explicit stack(Sequence&& seq) noexcept(is_nothrow_move_constructible_v<Sequence>) :
    seq_(_NEFORCE move(seq)) {}

    NEFORCE_NODISCARD size_type size() const noexcept(noexcept(seq_.size())) { return seq_.size(); }

    NEFORCE_NODISCARD bool empty() const noexcept(noexcept(seq_.empty())) { return seq_.empty(); }

    NEFORCE_NODISCARD reference top() noexcept(noexcept(seq_.back())) { return seq_.back(); }

    NEFORCE_NODISCARD const_reference top() const noexcept(noexcept(seq_.back())) { return seq_.back(); }

    template <typename... Args>
    decltype(auto) emplace(Args&&... args) {
        return seq_.emplace_back(_NEFORCE forward<Args>(args)...);
    }

    void push(const value_type& value) { seq_.push_back(value); }

    void push(value_type&& value) { seq_.push_back(_NEFORCE move(value)); }

    void pop() noexcept(noexcept(seq_.pop_back())) { seq_.pop_back(); }

    void swap(stack& other) noexcept(is_nothrow_swappable_v<Sequence>) { _NEFORCE swap(seq_, other.seq_); }

    NEFORCE_NODISCARD bool equal_to(const stack& rhs) const noexcept(noexcept(seq_ == rhs.seq_)) {
        return seq_ == rhs.seq_;
    }

    NEFORCE_NODISCARD bool less_than(const stack& rhs) const noexcept(noexcept(seq_ < rhs.seq_)) {
        return seq_ < rhs.seq_;
    }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename Sequence>
stack(Sequence) -> stack<typename Sequence::value_type, Sequence>;
#endif
 // Container
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_CONTAINER_STACK_HPP__