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

//
// 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
//

#ifndef __BFIG__
#define __BFIG__

#include <cstdlib>
#include <vector>

#include <Mers/Utils/Lang/String.h>
#include <Mers/Utils/Logging/logger.h>

#include "BFIGImplicantHeap.h"

namespace Mers {
        namespace Generators {
                namespace BFIG {

                        class BFIGImplicant;
                        class BFIGConstraint;
                        class BFIGVariable;
                        class BFIGAssignment;
                        class BFIGObjectiveFunction;

                        class BFIG
                        {
                        public:
                                //      CONSTRUCTOR

                                BFIG(std::vector<BFIGVariable *> const & variableSet, double cutoffCost, 
                                                BFIGObjectiveFunction const * of);

                                BFIG(std::vector<BFIGVariable *> const & variableSet, double cutoffCost);

                                BFIG(std::vector<BFIGVariable *> const & variableSet);

                                virtual ~BFIG();


                                //      PUBLIC FUNCTION METHODS

                                //      Gets and Sets

                                virtual Mers::Utils::Lang::String const getName()  const;

                                virtual BFIGVariable * getVariableByName(unsigned int variableName);
                                virtual BFIGVariable * getVariableByName(Mers::Utils::Lang::String variableName);
                                virtual std::vector<BFIGVariable *> getVariables()  const;

                                virtual void setDebug(unsigned int debugState);

                                virtual void addConflict(BFIGConstraint const * newConflict);

                                virtual void 
                                addConflicts(std::vector<BFIGConstraint const *> const & newConflicts);

                                virtual BFIGImplicant const * 
                                getBestImplicant(long maximumVisitedStateCount, long maxQueueSize);

                                virtual void markBestFeasible();

                                virtual unsigned int getLargestQueue() const;

                                virtual unsigned int getLargestQueueSinceReset() const;

                                virtual unsigned int getNodesExpanded() const;
                                
                                virtual unsigned int getNumberCandidatesSinceReset() const;

                                virtual void printStatistics(bool verbose = false) const;

                                virtual void printStatistics(log4cplus::Logger logger, bool verbose = false, 
                                        log4cplus::LogLevel logLevel = log4cplus::DEBUG_LOG_LEVEL) const;

                                virtual void printQueue(bool verbose = false)  const;

                                virtual void printQueue(log4cplus::Logger logger, bool verbose = false, 
                                        log4cplus::LogLevel logLevel = log4cplus::DEBUG_LOG_LEVEL) const;

                                virtual void restart();

                                virtual void reset();

                                virtual unsigned int getNumberOfConflicts();

                        protected:

                                // Internal Functions

                                virtual BFIGImplicant * 
                                createNewImplicant(std::vector<BFIGConstraint const *> &con);

                                virtual void
                                searchForImplicant(long maxExpansionCount, long maxQueueSize) = 0;

                                virtual void
                                enqueueImplicants(std::vector<BFIGImplicant *> const & newImplicants);

                                virtual void enqueueImplicant(BFIGImplicant * newUnexploredImplicant);

                                virtual void insertSiblings(BFIGImplicant * sibling);

                                virtual void insertChildren(BFIGImplicant * parent);

                                virtual void insertExtensions(BFIGImplicant * node);

                                //      PRIVATE DATA MEMBERS
        
                                Mers::Utils::Lang::String mName;

                                std::vector<BFIGVariable *> mVariables;

                                BFIGObjectiveFunction const * mObjectiveFunction;

                                std::vector<BFIGConstraint const *> mConflicts;

                                BFIGImplicantHeap mImplicantQueue;

                                BFIGImplicant * mCandidate;

                                unsigned int mNodesExpanded;

                                unsigned int mLargestQueue;

                                unsigned int mLargestQueueSinceReset;

                                unsigned int mDebug;

                                unsigned int mNumSolutions;

                                unsigned int mNumCandidatesSinceReset;

                                static log4cplus::Logger mLogger;
                        };
                }
        }
}

#endif //ndef __BFIG__

---