fmdaryheap.hpp

#ifndef FMDARYHEAP_H_
#define FMDARYHEAP_H_

#include <boost/heap/d_ary_heap.hpp>

#include <fast_methods/datastructures/fmcompare.hpp>

template <class cell_t = FMCell> class FMDaryHeap {

    typedef boost::heap::d_ary_heap<const cell_t *, boost::heap::mutable_<true>, boost::heap::arity<2>, boost::heap::compare<FMCompare<cell_t>> > d_ary_heap_t;
    
    typedef typename d_ary_heap_t::handle_type handle_t;

    public:
        FMDaryHeap () {}
        
        FMDaryHeap (const size_t & n) { handles_.resize(n); }
        
        virtual ~ FMDaryHeap() { clear(); }
        
        void setMaxSize
        (const size_t & n) {
            handles_.resize(n);
        }
        
        void push
        (const cell_t * c) {
            handles_[c->getIndex()] = heap_.push(c);
        }
        
        unsigned int popMinIdx
        () {
            const unsigned int idx = heap_.top()->getIndex();
            heap_.pop();
            return idx;
        }
        
        size_t size
        () const {
            return heap_.size();
        }
        
        void update
        (const cell_t * c) {
            heap_.update(handles_[c->getIndex()], c);
        }
        
        void increase
        (const cell_t * c) {
            heap_.increase(handles_[c->getIndex()], c);
        }

        void clear
        () {
            heap_.clear();
            handles_.clear();
        }

        bool empty
        () const {
            return heap_.empty();
        }

    protected:
        d_ary_heap_t heap_;  
        std::vector<handle_t> handles_;
};


#endif /* FMDARYHEAP_H_ */