fmfibheap.hpp

#ifndef FMFIBHEAP_H_
#define FMFIBHEAP_H_

#include <boost/heap/fibonacci_heap.hpp>

#include <fast_methods/datastructures/fmcompare.hpp>

template <class cell_t = FMCell> class FMFibHeap {

    typedef boost::heap::fibonacci_heap<const cell_t *, boost::heap::compare<FMCompare<cell_t> > > fib_heap_t;

    typedef typename fib_heap_t::handle_type handle_t;

    public:
        FMFibHeap () {}

        FMFibHeap (const size_t & n) { handles_.resize(n);}
        virtual ~ FMFibHeap() {}

        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:
        fib_heap_t heap_;  
        std::vector<handle_t> handles_;
};


#endif /* FMFIBHEAP_H_ */