deque.h

Go to the documentation of this file.

#ifndef DEQUE_H
#define DEQUE_H

 
#include "chain.h"
#include "containerAdapter.h"
 
namespace original {

    template <typename TYPE,
              template <typename, typename> typename SERIAL = chain,
              template <typename> typename ALLOC = allocator>
    class deque final : public containerAdapter<TYPE, SERIAL, ALLOC> {
    public:

        explicit deque(const SERIAL<TYPE, ALLOC<TYPE>>& serial = SERIAL<TYPE, ALLOC<TYPE>>{});

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

        deque(const deque& other);

        deque& operator=(const deque& other);

        deque(deque&& other) noexcept;

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

        void pushBegin(const TYPE &e);

        void pushEnd(const TYPE &e);

        TYPE popBegin();

        TYPE popEnd();

        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::deque<TYPE, SERIAL, ALLOC>::deque(const SERIAL<TYPE, ALLOC<TYPE>>& serial)
        : containerAdapter<TYPE, SERIAL, ALLOC>(serial) {}
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    original::deque<TYPE, SERIAL, ALLOC>::deque(const std::initializer_list<TYPE> &lst)
        : deque(SERIAL<TYPE, ALLOC<TYPE>>(lst)) {}
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    original::deque<TYPE, SERIAL, ALLOC>::deque(const deque& other) : deque() {
        this->operator=(other);
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::operator=(const deque& other) -> deque& {
        if (this == &other) return *this;
        this->serial_ = other.serial_;
        return *this;
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    original::deque<TYPE, SERIAL, ALLOC>::deque(deque&& other) noexcept : deque()
    {
        this->operator=(std::move(other));
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::operator=(deque&& other) noexcept -> deque&
    {
        if (this == &other)
            return *this;
 
        this->serial_ = std::move(other.serial_);
        return *this;
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::pushBegin(const TYPE &e) -> void {
        this->serial_.pushBegin(e);
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::pushEnd(const TYPE &e) -> void {
        this->serial_.pushEnd(e);
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::popBegin() -> TYPE {
        return this->serial_.popBegin();
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::popEnd() -> TYPE {
        return this->serial_.popEnd();
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::head() const -> TYPE {
        return this->serial_.getBegin();
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::tail() const -> TYPE {
        return this->serial_.getEnd();
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    auto original::deque<TYPE, SERIAL, ALLOC>::className() const -> std::string {
        return "deque";
    }
 
#endif //DEQUE_H