queue.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_CONTAINER_QUEUE_HPP__
#define NEFORCE_CORE_CONTAINER_QUEUE_HPP__

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


template <typename T, typename Sequence = deque<T>>
class queue : public icollector<queue<T, Sequence>> {
    static_assert(is_object_v<T>, "queue only contains object types.");
    static_assert(is_same_v<T, typename Sequence::value_type>, "queue 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; 
    using iterator = typename Sequence::iterator;               
    using const_iterator = typename Sequence::const_iterator;   
 
private:
    Sequence seq_{}; 
 
public:
    queue() = default;

    explicit queue(const Sequence& other) :
    seq_(other) {}

    explicit queue(Sequence&& other) noexcept(is_nothrow_move_constructible_v<Sequence>) :
    seq_(_NEFORCE move(other)) {}

    ~queue() = default;

    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 front() noexcept(noexcept(seq_.front())) { return seq_.front(); }

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

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

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

    NEFORCE_NODISCARD iterator begin() noexcept(noexcept(seq_.begin())) { return seq_.begin(); }

    NEFORCE_NODISCARD iterator end() noexcept(noexcept(seq_.end())) { return seq_.end(); }

    NEFORCE_NODISCARD const_iterator begin() const noexcept(noexcept(seq_.begin())) { return seq_.begin(); }

    NEFORCE_NODISCARD const_iterator end() const noexcept(noexcept(seq_.end())) { return seq_.end(); }

    NEFORCE_NODISCARD const_iterator cbegin() const noexcept(noexcept(seq_.cbegin())) { return seq_.cbegin(); }

    NEFORCE_NODISCARD const_iterator cend() const noexcept(noexcept(seq_.cend())) { return seq_.cend(); }

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

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

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

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

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

    NEFORCE_NODISCARD bool operator==(const queue& rhs) const noexcept(noexcept(seq_ == rhs.seq_)) {
        return seq_ == rhs.seq_;
    }

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