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

//==============================================================================
// Copyright (c) 2001           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.
//==============================================================================
//# CHECKED MJP 08-07-2002

#include "BFIGImplicantExpander.h"

#include <cassert>
#include "BFIGImplicant.h"
#include "BFIGVariable.h"
#include "BFIGAssignment.h"

using Mers::Generators::BFIG::BFIGImplicant;
using Mers::Generators::BFIG::BFIGImplicantExpander;
using Mers::Generators::BFIG::BFIGAssignment;
using Mers::Generators::BFIG::BFIGVariable;
using std::cout;
using std::endl;
using std::list;


#ifdef _MSC_VER
#include "ListManipulator.h"
using Mers::Generators::BFIG::ListManipulator;
template  ListManipulator<BFIGVariable *>;
//template  ListManipulator<BFIGAssignment const *>;
#else
typedef bool (*variable_comp_func)(BFIGVariable *, BFIGVariable *);
//typedef bool (*assignment_comp_func)(BFIGAssignment const *, BFIGAssignment const *);
#endif


static void
printAssignmentList(list<BFIGAssignment const *> const & as)
{
        (void)printAssignmentList;
        cout << "(";
        list<BFIGAssignment const *>::const_iterator aIter;
        bool start = true;
        for (aIter = as.begin(); aIter != as.end(); aIter++)
        {
                if (start)
                        start = false;
                else
                        cout << ", ";
                if (*aIter)
                        cout << *(*aIter);
                else
                        cout << "NULL";
        }
        cout << ")";
}

static void
printVariableList(list<BFIGVariable *> const & as)
{
        (void)printVariableList;
        cout << "(";
        list<BFIGVariable *>::const_iterator aIter;
        bool start = true;
        for (aIter = as.begin(); aIter != as.end(); aIter++)
        {
                if (start)
                        start = false;
                else
                        cout << ", ";
                if (*aIter)
                        cout << *(*aIter);
                else
                        cout << "NULL";
        }
        cout << ")";
}


static bool
variable_name_less(BFIGVariable * v1, BFIGVariable * v2)
{
        return ( v1->getName() < v2->getName() );
}

/*#
//static bool
//assignment_name_less(BFIGAssignment const * a1, BFIGAssignment const * a2)
//{
//      return ( a1->getName() < a2->getName() );
//}
*/

BFIGImplicantExpander::BFIGImplicantExpander()
: variableSet()
{
        //cout << "warning: default ImplicantExpander constructor called." << endln;
}


BFIGImplicantExpander::BFIGImplicantExpander(list<BFIGVariable *> const & variables)
: variableSet(variables)
{
#ifdef _MSC_VER
        ListManipulator<BFIGVariable *> lm;
        lm.sort(variableSet, variable_name_less);
#else
        variableSet.sort<variable_comp_func>(variable_name_less);
#endif
/*#
        //cout << endl << endl << "Implicant Expander:" << endl;
        //printVariableList(variableSet);
        //cout << endl;
        //variableSet.sort();
        //printVariableList(variableSet);
        //cout << endl;
        //cout << endl << endl;
*/
}


Mers::Generators::BFIG::BFIGImplicant *
BFIGImplicantExpander::expandImplicant(BFIGImplicant const & partialImplicant)  const
{
        BFIGImplicant * res = new BFIGImplicant(partialImplicant);
        expandImplicant(res);
        return res;
}


void
BFIGImplicantExpander::expandImplicant(BFIGImplicant * imp)  const
{
        // would be a mess otherwise anyway  - but be careful!:
        imp->eliminateSiblings();

        // loop through all variables we are dealing with
        list<BFIGVariable *>::const_iterator variableIter;
        for (variableIter = variableSet.begin();  //, assignmentIter = oldAssignments.begin();
             variableIter != variableSet.end(); variableIter++)
        {
                if (!imp->contains((*variableIter)))
                {
                        BFIGAssignment const * newAssign = (*variableIter)->getBestAssignment();
                        if (newAssign)  // ignore if null??
                        {
                                imp->addAssignment(newAssign);
                        }
                }
        }
        // keeps original assignments first in unsorted list of Implicant...
}

---