queue.h

Go to the documentation of this file.

#ifndef QUEUE_H
#define QUEUE_H

 
#include "containerAdapter.h"
#include "chain.h"
#include <string>
 
namespace original {

    template<typename TYPE,
             template <typename, typename> typename SERIAL = chain,
             template <typename> typename ALLOC = allocator>
    class queue final : public containerAdapter<TYPE, SERIAL, ALLOC> {
    public:
        explicit queue(const SERIAL<TYPE, ALLOC<TYPE>>& serial = SERIAL<TYPE, ALLOC<TYPE>>{});

        queue(const std::initializer_list<TYPE>& lst);

        queue(const queue& other);

        queue& operator=(const queue& other);

        queue(queue&& other) noexcept;

        queue& operator=(queue&& other) noexcept;

        void push(const TYPE& e);

        TYPE pop();

        TYPE head() const;

        TYPE tail() const;

        [[nodiscard]] std::string className() const override;
    };
}
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    original::queue<TYPE, SERIAL, ALLOC>::queue(const SERIAL<TYPE, ALLOC<TYPE>>& serial)
        : containerAdapter<TYPE, SERIAL, ALLOC>(serial) {}
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    original::queue<TYPE, SERIAL, ALLOC>::queue(const std::initializer_list<TYPE> &lst)
        : queue(SERIAL<TYPE, ALLOC<TYPE>>(lst)) {}
 
    template<typename TYPE,
         template <typename, typename> typename SERIAL,
         template <typename> typename ALLOC>
    original::queue<TYPE, SERIAL, ALLOC>::queue(const queue& other)
        : containerAdapter<TYPE, SERIAL, ALLOC>(other.serial_) {}
 
    template<typename TYPE,
         template <typename, typename> typename SERIAL,
         template <typename> typename ALLOC>
    auto original::queue<TYPE, SERIAL, ALLOC>::operator=(const queue& other) -> queue& {
        if (this == &other) return *this;
        this->serial_ = other.serial_;
        return *this;
    }
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    original::queue<TYPE, SERIAL, ALLOC>::queue(queue&& other) noexcept : queue()
    {
        this->operator=(std::move(other));
    }
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    auto original::queue<TYPE, SERIAL, ALLOC>::operator=(queue&& other) noexcept -> queue&
    {
        if (this == &other)
            return *this;
 
        this->serial_ = std::move(other.serial_);
        other.serial_ = SERIAL<TYPE, ALLOC<TYPE>>{};
        return *this;
    }
 
    template<typename TYPE,
         template <typename, typename> typename SERIAL,
         template <typename> typename ALLOC>
    auto original::queue<TYPE, SERIAL, ALLOC>::push(const TYPE& e) -> void {
        this->serial_.pushEnd(e);
    }
 
    template<typename TYPE,
         template <typename, typename> typename SERIAL,
         template <typename> typename ALLOC>
    auto original::queue<TYPE, SERIAL, ALLOC>::pop() -> TYPE {
        return this->serial_.popBegin();
    }
 
    template<typename TYPE,
         template <typename, typename> typename SERIAL,
         template <typename> typename ALLOC>
    auto original::queue<TYPE, SERIAL, ALLOC>::head() const -> TYPE {
        return this->serial_.getBegin();
    }
 
    template<typename TYPE,
         template <typename, typename> typename SERIAL,
         template <typename> typename ALLOC>
    auto original::queue<TYPE, SERIAL, ALLOC>::tail() const -> TYPE {
        return this->serial_.getEnd();
    }
 
    template<typename TYPE,
         template <typename, typename> typename SERIAL,
         template <typename> typename ALLOC>
    std::string original::queue<TYPE, SERIAL, ALLOC>::className() const {
        return "queue";
    }
 
#endif //QUEUE_H