/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/BFIGImplicantHeap.cpp

//
// Copyright (c) 2004           Model-based Embedded and Robotic Systems Group
// All Rights Reserved          Massachusetts Institute of Technology
//
// This software is provided as is. Model-based Embedded and Robotic Systems
// (MERS) group does not assume any responsibility.
//
// Organization:        Model-based Embedded and Robotic Systems Group
//                                      Massachusetts Institute of Technology
//

#include "BFIGImplicantHeap.h"

#include "BFIGImplicant.h"


using namespace Mers::Generators::BFIG;
using std::ostream;

// Construction/Destruction

BFIGImplicantHeap::BFIGImplicantHeap(bool greatestOnTop, double maximumCost,
        bool owner)
        : DynamicHeap(greatestOnTop, DynamicArray::DAHBFIGImplicantHeap, owner),
        mPruneByCost(true), mMaximumCost(maximumCost)
{
        //fprintf(stderr, "Costs: %f = %f\n", mMaximumCost, maximumCost);
}


BFIGImplicantHeap::BFIGImplicantHeap(bool greatestOnTop, bool owner)
        : DynamicHeap(greatestOnTop, DynamicArray::DAHBFIGImplicantHeap, owner),
        mPruneByCost(false), mMaximumCost(0)
{
}


BFIGImplicantHeap::~BFIGImplicantHeap()
{
        makeEmpty();
}


int BFIGImplicantHeap::insert(HeapElement * element)
{
        //fprintf(stderr, "BFIGImplicantHeap: Insert; MCost(%f), Cost(%f)\n",
        //                              mMaximumCost, element->getBestCost());
        if(mPruneByCost && element->getBestCost() > mMaximumCost) {
                //fprintf(stderr, "BFIGImplicantHeap: Insert; Rejected\n");
                if(ownsElements) {
                        delete element;
                }
                return 0;
        } else {
                return DynamicHeap::insert((void *) element);
        }
}


int BFIGImplicantHeap::peekFirst(HeapElement * &element)
{
        return DynamicHeap::peekFirst((void * &) element);
}


int BFIGImplicantHeap::getFirst(HeapElement * &element)
{
        return DynamicHeap::getFirst((void * &) element);
}


#ifndef EMBEDDED
void BFIGImplicantHeap::printElement(ostream &out, void const * element) const
{
        HeapElement const &e = *(HeapElement const *) element;

        out << e;
}
#endif


void BFIGImplicantHeap::deleteElement(void * element) const
{
        delete (HeapElement *) element;
}


void * BFIGImplicantHeap::newElement(void const * element) const
{
        return new HeapElement(*(HeapElement const *)element);
}


bool BFIGImplicantHeap::greaterThan(void const * e1, void const * e2) const
{
        HeapElement const &element1 = *(HeapElement const *) e1;
        HeapElement const &element2 = *(HeapElement const *) e2;

        return element1 > element2;
}


bool BFIGImplicantHeap::lessThan(void const * e1, void const * e2) const
{
        HeapElement const &element1 = *(HeapElement const *) e1;
        HeapElement const &element2 = *(HeapElement const *) e2;

        return element1 < element2;
}

---