THeap.h

#pragma once


#include <libutl/THeapIt.h>


UTL_NS_BEGIN;



template <class T>
class THeap : public Heap
{
    UTL_CLASS_DECL_TPL(THeap, T, Heap);
    UTL_CLASS_DEFID;

public:
    THeap(size_t size,
          size_t increment = uint_t_max,
          bool owner = true,
          bool multiSet = true,
          Ordering* ordering = nullptr);

    THeap(bool owner, bool multiSet = true);

    bool
    add(const T& object)
    {
        return super::add(const_cast<T&>(object));
    }

    bool
    add(const T* object)
    {
        return super::add(const_cast<T*>(object));
    }

    void
    add(const Collection& collection)
    {
        super::add(collection);
    }

    THeapIt<T>
    begin() const
    {
        THeapIt<T> res;
        res.copy(Heap::begin());
        return res;
    }

    THeapIt<T>
    begin()
    {
        THeapIt<T> res;
        res.copy(Heap::begin());
        return res;
    }

    THeapIt<T>
    end() const
    {
        THeapIt<T> res;
        res.copy(Heap::end());
        return res;
    }

    THeapIt<T>
    end()
    {
        THeapIt<T> res;
        res.copy(Heap::end());
        return res;
    }

    T*
    findT(const Object& key) const
    {
        return utl::cast<T>(Heap::find(key));
    }

    T*
    pop()
    {
        return utl::cast<T>(Heap::pop());
    }

public:
    typedef T type;
    typedef THeapIt<T> iterator;
    typedef T* value_type; // for STL
};


template <class T>
THeap<T>::THeap(size_t size, size_t increment, bool owner, bool multiSet, Ordering* ordering)
    : Heap(size, increment, owner, multiSet, ordering)
{
}


template <class T>
THeap<T>::THeap(bool owner, bool multiSet)
    : Heap(owner, multiSet)
{
}


UTL_NS_END;


UTL_CLASS_IMPL_TPL(utl::THeap, T);