/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/BFIGConflict.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

#ifdef _MSC_VER
#pragma warning( disable : 4786 )
#endif

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

// MSVC does not support template methods, but we can use a work-around.
#ifdef _MSC_VER
#include "ListManipulator.h"
using Mers::Generators::BFIG::ListManipulator;
template ListManipulator<BFIGAssignment const *>;
#else
typedef bool (*assignment_comp_func)(BFIGAssignment const *, BFIGAssignment const *);
#endif

#include "BFIGConflict.h"

using namespace std;

static bool
assignment_cost_less(BFIGAssignment const * a1, BFIGAssignment const * a2)
{
        return ( a1->getCost() < a2->getCost() );
}

static bool
assignment_less(BFIGAssignment const * a1, BFIGAssignment const * a2)
{
        return ( (*a1) < (*a2) );
}

        //------------------------------------
        //      CONSTRUCTOR
        //------------------------------------
/*#
BFIGConflict::BFIGConflict(list<BFIGAssignment const *> inconsistentAssignments_pList,
                   list<BFIGAssignment const *> primeImplicants_pList)
{
        inconsistentAssignments = inconsistentAssignments_pList;
        primeImplicants = primeImplicants_pList;
}
*/

BFIGConflict::BFIGConflict(list<BFIGAssignment const *> inconsistentAssignments_pList)
: primeImplicants()
{
        inconsistentAssignments = inconsistentAssignments_pList;
        // sort the assignments for comparison
        #ifdef _WIN32
        #ifndef __CYGWIN__
        {
                ListManipulator<BFIGAssignment const *> lm;
                lm.sort(inconsistentAssignments, assignment_less);
        }
        #else
        inconsistentAssignments.sort<assignment_comp_func>(assignment_less);
        #endif
        #else
        inconsistentAssignments.sort<assignment_comp_func>(assignment_less);
        #endif

        createPrimeImplicants();
}

/*#
BFIGConflict::BFIGConflict()
{
        //cout << "warning: default Conflict constructor called." << endln;
}
*/

        //------------------------------------
        //      PUBLIC FUNCTION METHODS
        //------------------------------------

list<BFIGAssignment const *>
BFIGConflict::getInconsistentAssignments() const
{
        return inconsistentAssignments;
}

list<BFIGAssignment const *>
BFIGConflict::getPrimeImplicants() const
{
        return primeImplicants;
}


int
BFIGConflict::getLength() const
{
        return inconsistentAssignments.size();
}

bool
BFIGConflict::isEmpty() const
{
        return (getLength() == 0);
}


void
BFIGConflict::createPrimeImplicants()
        //******************************
        //      This function will take the list of inconsistentAssignments and create a list of
        //      assignments that are not in this list.  This list represents the set of assignments
        //      that will entail the conflict.  Choosing only one of these assignments will then resolve
        //      the conflict.
        //******************************
{
        list<BFIGAssignment const *>::const_iterator inconsistentAssignmentsIter;
        list<BFIGAssignment const *> tempAssignment_pList;
        list<BFIGAssignment const *>::iterator tempAssignmentIter;

        for (inconsistentAssignmentsIter = inconsistentAssignments.begin();
             inconsistentAssignmentsIter != inconsistentAssignments.end();
             inconsistentAssignmentsIter++)
        {
                tempAssignment_pList = (*inconsistentAssignmentsIter)->alternateAssignments();

                for (tempAssignmentIter = tempAssignment_pList.begin();
                     tempAssignmentIter != tempAssignment_pList.end();
                     tempAssignmentIter++)
                {
                        primeImplicants.push_back(*tempAssignmentIter);
                }
        }

#ifdef _WIN32
#ifndef __CYGWIN__
        ListManipulator<BFIGAssignment const *> lm;
        lm.sort(primeImplicants, assignment_cost_less);
#else
        primeImplicants.sort<assignment_comp_func>(assignment_cost_less);
#endif
#else
        primeImplicants.sort<assignment_comp_func>(assignment_cost_less);
#endif
}


/*#
void
BFIGConflict::recordConflict()
        // **************************
        //      This function will take each assignment in the primeImplicants of a conflict
        //      and set the field in its assignment to note that the assignment entails this
        //      conflict.
        // ***************************
{
        list<BFIGAssignment const *>::const_iterator primeImplIter;

        //      Iterate through the assignments in primeImplicants, and set their entailedConflicts
        //      field to point to this conflict.
        for (primeImplIter = primeImplicants.begin(); primeImplIter != primeImplicants.end();
                 primeImplIter++)
                 {
                 }
}
*/


/*#
void
BFIGConflict::trySupportingConflict(Implicant const * currentImplNode)
        // **************************************
        //      This function checks if the assignments in its primeImplicants list are in the
        //      current Implicant of BFIG.  It does this by comparing the assignments in
        //      the primeImplicants list to the ones in currentImplicant's assignments.
        //      If they are equal, then it adds the assignment as a support for the conflict.
        //
        //      Question:  If a conflict can be supported by multiple assignments, this is not
        //              considered.  This type of check would be expensive, which is why it may not
        //              have been in the original Lisp implementation. ???
{
        list<BFIGAssignment const *>::const_iterator
                primeImplIter = primeImplicants.begin();
        list<BFIGAssignment const *>::const_iterator
                ImplNodeAssignmentIter = currentImplNode->getAssignments().begin();
        bool isSupported = false;

        while (primeImplIter != primeImplicants.end() && !isSupported)
        {
                while (ImplNodeAssignmentIter != currentImplNode->getAssignments().end() &&
                       !isSupported)
                {
                        if ((*primeImplIter) == (*ImplNodeAssignmentIter))
                        {
                                isSupported = true;
                                currentEntailedAssignment = (*primeImplIter);
                        }
                        else currentEntailedAssignment = NULL;
                }
        }
}
*/


bool
BFIGConflict::supportedBy(Implicant const * implicant) const
{
        list<BFIGAssignment const *> assignments = implicant->getAssignments();
        list<BFIGAssignment const *>::const_iterator assignmentsIter;
        for (assignmentsIter = assignments.begin(); assignmentsIter != assignments.end();
                 assignmentsIter++)
        {
                list<BFIGAssignment const *>::const_iterator conflictAssignmentsIter;
                for (conflictAssignmentsIter = inconsistentAssignments.begin();
                     conflictAssignmentsIter != inconsistentAssignments.end();
                         conflictAssignmentsIter++)
                {
                        if (! (*assignmentsIter)->compatible(*conflictAssignmentsIter) )
                        {
                                return true;
                        }
                }
        }
        return false;
}


bool
BFIGConflict::supportedBy(BFIGAssignment const * a) const
{
        list<BFIGAssignment const *>::const_iterator conflictAssignmentsIter;
        for (conflictAssignmentsIter = inconsistentAssignments.begin();
             conflictAssignmentsIter != inconsistentAssignments.end();
                 conflictAssignmentsIter++)
        {
                if (! a->compatible(*conflictAssignmentsIter) )
                {
                        return true;
                }
        }
        return false;
}


bool
BFIGConflict::operator==(BFIGConflict const & c)  const
{
        // Assumes constraints are in minimal form:
        if (getLength() != c.getLength())
                return false;

        // Could also fail if they are not minimal:
        list<BFIGAssignment const *>::const_iterator c1Iter;
        list<BFIGAssignment const *>::const_iterator c2Iter;
        for (c1Iter = inconsistentAssignments.begin(), c2Iter = c.inconsistentAssignments.begin();
             c1Iter != inconsistentAssignments.end(); c1Iter++, c2Iter++)
        {
                if (!( (*c1Iter) == (*c2Iter) ))
                        return false;
        }

        return true;
}


bool
BFIGConflict::operator<(BFIGConflict const & c)  const
{
        if (getLength() < c.getLength())
                return true;
        if (getLength() > c.getLength())
                return false;

        list<BFIGAssignment const *>::const_iterator c1Iter;
        list<BFIGAssignment const *>::const_iterator c2Iter;
        for (c1Iter = inconsistentAssignments.begin(), c2Iter = c.inconsistentAssignments.begin();
             c1Iter != inconsistentAssignments.end(); c1Iter++, c2Iter++)
        {
                if ((*c1Iter) == (*c2Iter))
                        continue;
                if ((*(*c1Iter)) < (*(*c2Iter)))
                        return true;
                return false;
        }

        return false;
}


String
BFIGConflict::toString() const
{
        list<BFIGAssignment const *>::const_iterator conflictIter;
        list<BFIGAssignment const *> conflictInconsistent = inconsistentAssignments;

        String res = "";
        res += " ( " ;
        for (conflictIter = conflictInconsistent.begin();
                 conflictIter != conflictInconsistent.end(); conflictIter++)
        {
                res += (*conflictIter)->toString();
        }
        res += " )" ;
        // res += "\n" ;
        return res;
}

ostream&
operator<<(ostream& os, BFIGConflict const & c)
{
        list<BFIGAssignment const *>::const_iterator conflictIter;
        list<BFIGAssignment const *> conflictInconsistent = c.inconsistentAssignments;

        os << "(" ;
        for (conflictIter = conflictInconsistent.begin();
                 conflictIter != conflictInconsistent.end(); conflictIter++)
        {
                os << *(*conflictIter) << " ";
        }
        os << ")" ;
        return os;
}

        //------------------------------------
        //      PRIVATE FUNCTION METHODS
        //------------------------------------

---