stack.h

Go to the documentation of this file.

#ifndef STACK_H
#define STACK_H
 
#include "chain.h"
#include "containerAdapter.h"
#include <string>
 
namespace original {
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL = chain,
             template <typename> typename ALLOC = allocator>
    class stack final : public containerAdapter<TYPE, SERIAL, ALLOC> {
    public:
        explicit stack(const SERIAL<TYPE, ALLOC<TYPE>>& serial = SERIAL<TYPE, ALLOC<TYPE>>{});
 
        stack(const std::initializer_list<TYPE>& lst);
 
        stack(const stack& other);
 
        stack& operator=(const stack& other);
 
        stack(stack&& other) noexcept;
 
        stack& operator=(stack&& other) noexcept;
 
        void push(const TYPE& e);
 
        TYPE pop();
 
        TYPE top() const;
 
        [[nodiscard]] std::string className() const override;
    };
}
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    original::stack<TYPE, SERIAL, ALLOC>::stack(const SERIAL<TYPE, ALLOC<TYPE>>& serial)
        : containerAdapter<TYPE, SERIAL, ALLOC>(serial) {}
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    original::stack<TYPE, SERIAL, ALLOC>::stack(const std::initializer_list<TYPE> &lst)
        : stack(SERIAL<TYPE, ALLOC<TYPE>>(lst)) {}
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    original::stack<TYPE, SERIAL, ALLOC>::stack(const stack& other)
        : containerAdapter<TYPE, SERIAL, ALLOC>(other.serial_) {}
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    auto original::stack<TYPE, SERIAL, ALLOC>::operator=(const stack& other) -> stack& {
        if (this == &other) return *this;
        this->serial_ = other.serial_;
        return *this;
    }
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    original::stack<TYPE, SERIAL, ALLOC>::stack(stack&& other) noexcept : stack()
    {
        this->operator=(std::move(other));
    }
 
    template<typename TYPE,
         template <typename, typename> typename SERIAL,
         template <typename> typename ALLOC>
    auto original::stack<TYPE, SERIAL, ALLOC>::operator=(stack&& other) noexcept -> stack&
    {
        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::stack<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::stack<TYPE, SERIAL, ALLOC>::pop() -> TYPE {
        return this->serial_.popEnd();
    }
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    auto original::stack<TYPE, SERIAL, ALLOC>::top() const -> TYPE {
        return this->serial_.getEnd();
    }
 
    template<typename TYPE,
             template <typename, typename> typename SERIAL,
             template <typename> typename ALLOC>
    std::string original::stack<TYPE, SERIAL, ALLOC>::className() const {
        return "stack";
    }
 
#endif // STACK_H