/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/BFIGConstraintUnit.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
//
//# CHECKED MJP 08-07-2002

#include "BFIGConstraintUnit.h"

#include <cassert>
#include <iostream>

#include "BFIGVariable.h"
#include "BFIGAssignment.h"


using namespace Mers::Generators::BFIG;
using Mers::Utils::Lang::String;
using std::ostream;


BFIGConstraintUnit::~BFIGConstraintUnit()
{
}


BFIGConstraintUnit::BFIGConstraintUnit(BFIGAssignment const * a, bool parityBit)
: constraintAssignment(a), parity(parityBit)
{
        assert(a);
        //constraintAssignment = a;
        //parity = parityBit;
}


BFIGConstraintUnit::BFIGConstraintUnit(BFIGConstraintUnit const & cu)
: constraintAssignment(cu.constraintAssignment), parity(cu.parity)
{
        assert(constraintAssignment);
        //constraintAssignment = cu.constraintAssignment;
        //parity = cu.parity;
}


BFIGConstraintUnit
BFIGConstraintUnit::negated()  const
{
        return BFIGConstraintUnit(constraintAssignment, !parity);
}


Mers::Generators::BFIG::BFIGAssignment const *
BFIGConstraintUnit::getAssignment()  const
{
        return constraintAssignment;
}


Mers::Generators::BFIG::BFIGVariable const *
BFIGConstraintUnit::getVariable()  const
{
        if (constraintAssignment == NULL)
                return NULL;
        return constraintAssignment->getVariable();
}


unsigned int
BFIGConstraintUnit::getValue()  const
{
        if (constraintAssignment == NULL)
                return 0;
        return constraintAssignment->getValue();
}


String
BFIGConstraintUnit::getValueString()  const
{
        if (constraintAssignment == NULL)
                return "nil";
        return constraintAssignment->getValueString();
}


unsigned int
BFIGConstraintUnit::getValueInt()  const
{
        if (constraintAssignment == NULL)
                return 0;
        return constraintAssignment->getValueInt();
}


unsigned int
BFIGConstraintUnit::getName()  const
{
        if (constraintAssignment == NULL)
                return 0;
        return constraintAssignment->getName();
}


String
BFIGConstraintUnit::getNameString()  const
{
        if (constraintAssignment == NULL)
                return "nil";
        return constraintAssignment->getNameString();
}


unsigned int
BFIGConstraintUnit::getNameInt()  const
{
        if (constraintAssignment == NULL)
                return 0;
        return constraintAssignment->getNameInt();
}


bool
BFIGConstraintUnit::getParity()  const
{
        return parity;
}


/*
bool
BFIGConstraintUnit::isSatisfiedCurrent()  const
{
        if (constraintAssignment == NULL)
                return false;
        if (constraintAssignment->getVariable()->getCurrentAssignment() == NULL)
        {
                cerr << "Warning: ConstraintUnit " << (*this) << " depends on uncertain value!" << endl;
                return false;
        }
        return (constraintAssignment->isCurrent() == getParity());
}
*/


/*
bool
BFIGConstraintUnit::uncertain()  const
{
        if (constraintAssignment->getVariable()->getCurrentAssignment() == NULL)
        {
                return true;
        }
        return true;
}
*/


/*
bool
BFIGConstraintUnit::maybeSatisfiedCurrent()  const
{
        if (constraintAssignment == NULL)
                return false;
        if (constraintAssignment->getVariable()->getCurrentAssignment() == NULL)
        {
                cerr << "Warning: ConstraintUnit " << (*this) << " depends on uncertain value!" << endl;
                return true;
        }
        return (constraintAssignment->isCurrent() == getParity());
}
*/


bool
BFIGConstraintUnit::operator<(BFIGConstraintUnit const & c)  const
{
        assert(getVariable());
        assert(c.getVariable());
        if (getAssignment() == NULL && c.getAssignment() != NULL)
                return true;
        if (getAssignment() != NULL && c.getAssignment() == NULL)
                return false;
        if (getAssignment() == NULL && c.getAssignment() == NULL)
                return (getParity() && !(c.getParity()));
        if (getName() < c.getName())
                return true;
        if (getName() > c.getName())
                return false;
        if (getValue() < c.getValue())
                return true;
        if (getValue() > c.getValue())
                return false;
        if (getParity() && !(c.getParity()))
                return true;

        return false;
}


/*#
//bool
//BFIGConstraintUnit::operator==(BFIGConstraintUnit const * c)  const
//{
//      return *this == *c;
//}
*/


bool
BFIGConstraintUnit::operator==(BFIGConstraintUnit const & c)  const
{
        if (getAssignment() == NULL && c.getAssignment() != NULL)
                return false;
        if (getAssignment() != NULL && c.getAssignment() == NULL)
                return false;
        if (getParity() != c.getParity())
                return false;
        if (getAssignment() == NULL && c.getAssignment() == NULL)
                return true;
        return *(getAssignment()) == *(c.getAssignment());
}


BFIGConstraintUnit const &
BFIGConstraintUnit::operator =(BFIGConstraintUnit const & c)
{
        parity = c.parity;
        constraintAssignment = c.constraintAssignment;
        return *this;
}


String
BFIGConstraintUnit::getDescription()  const
{
        String res = "";
        if (! getParity())
                res += "!";
        if (getAssignment())
        {
                res += getAssignment()->getNameString();
                res += "=";
                res += getAssignment()->getValueString();
        } else
        {
                res += "nil";
        }
        return res;
}


namespace Mers {
        namespace Generators {
                namespace BFIG {

                        ostream&
                        operator<<(ostream& os, BFIGConstraintUnit const & c)
                        {
                                // for now - seems reasonable.
                                if (! c.getParity())
                                        os << "!";
                                if (c.getAssignment())
                                        os << *(c.getAssignment());
                                else
                                        os << "nil";
                                return os;
                        }

                }
        }
}

---