prique.h

Go to the documentation of this file.

#ifndef PRIQUE_H
#define PRIQUE_H

 
#include "algorithms.h"
#include "blocksList.h"
#include "comparator.h"
#include "containerAdapter.h"
#include "types.h"
 
namespace original
{
    template<typename TYPE,
            template <typename> typename Callback = increaseComparator,
            template <typename, typename> typename SERIAL = blocksList,
            template <typename> typename ALLOC = allocator>
    requires Compare<Callback<TYPE>, TYPE>
    class prique final : public containerAdapter<TYPE, SERIAL, ALLOC>
    {
        Callback<TYPE> compare_; 
 
    public:
        explicit prique(const SERIAL<TYPE, ALLOC<TYPE>>& serial = SERIAL<TYPE, ALLOC<TYPE>>{},
                        const Callback<TYPE>& compare = Callback<TYPE>{});

        prique(const std::initializer_list<TYPE>& lst,
               const Callback<TYPE>& compare = Callback<TYPE>{});

        prique(const prique& other);

        prique& operator=(const prique& other);

        prique(prique&& other) noexcept;

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

        void push(const TYPE& e);

        TYPE pop();

        TYPE top() const;

        [[nodiscard]] std::string className() const override;
    };
}
 
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    original::prique<TYPE, Callback, SERIAL, ALLOC>::prique(const SERIAL<TYPE, ALLOC<TYPE>>& serial, const Callback<TYPE>& compare)
        : containerAdapter<TYPE, SERIAL, ALLOC>(serial), compare_(compare)
    {
        algorithms::heapInit(this->serial_.begin(), this->serial_.last(), this->compare_);
    }
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    original::prique<TYPE, Callback, SERIAL, ALLOC>::prique(const std::initializer_list<TYPE>& lst, const Callback<TYPE>& compare)
        : prique(SERIAL<TYPE, ALLOC<TYPE>>(lst), compare) {}
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    original::prique<TYPE, Callback, SERIAL, ALLOC>::prique(const prique& other)
        : containerAdapter<TYPE, SERIAL, ALLOC>(other.serial_), compare_(other.compare_) {}
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    auto original::prique<TYPE, Callback, SERIAL, ALLOC>::operator=(const prique& other) -> prique&
    {
        if (this == &other) return *this;
        this->serial_ = other.serial_;
        compare_ = other.compare_;
        return *this;
    }
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    original::prique<TYPE, Callback, SERIAL, ALLOC>::prique(prique&& other) noexcept : prique()
    {
        this->operator=(std::move(other));
    }
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    auto original::prique<TYPE, Callback, SERIAL, ALLOC>::operator=(prique&& other) noexcept -> prique&
    {
        if (this == &other)
            return *this;
 
        this->serial_ = std::move(other.serial_);
        this->compare_ = std::move(other.compare_);
        return *this;
    }
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    auto original::prique<TYPE, Callback, SERIAL, ALLOC>::push(const TYPE& e) -> void
    {
        this->serial_.pushEnd(e);
        algorithms::heapAdjustUp(this->serial_.begin(), this->serial_.last(), this->compare_);
    }
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    auto original::prique<TYPE, Callback, SERIAL, ALLOC>::pop() -> TYPE
    {
        if (this->empty()) throw noElementError();
 
        algorithms::swap(this->serial_.begin(), this->serial_.last());
        TYPE res = this->serial_.popEnd();
        algorithms::heapAdjustDown(this->serial_.begin(), this->serial_.last(), this->serial_.begin(), this->compare_);
        return res;
    }
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    auto original::prique<TYPE, Callback, SERIAL, ALLOC>::top() const -> TYPE
    {
        return this->serial_.getBegin();
    }
 
    template<typename TYPE,
            template <typename> typename Callback,
            template <typename, typename> typename SERIAL,
            template <typename> typename ALLOC>
    requires original::Compare<Callback<TYPE>, TYPE>
    auto original::prique<TYPE, Callback, SERIAL, ALLOC>::className() const -> std::string
    {
        return "prique";
    }
 
#endif //PRIQUE_H