/Users/fpy/titan-1-5-MBARI/Mers/Models/Base/BaseModelAssignment.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 "BaseModelAssignment.h"
#include <Mers/Utils/Exceptions/RuntimeException.h>
#include <Mers/Utils/Lang/String.h>
#include <cstdio>
#include <cassert>


using namespace Mers::Models::Base;
using Mers::Utils::Exceptions::RuntimeException;
using Mers::Utils::Lang::String;
using std::ostream;

// Construction/Destruction

BaseModelAssignment::BaseModelAssignment(BaseModelVariable const * myVariable, 
        BaseModelValue const * myValue, OperatorType myOpType)
: BaseModelObject(BaseModelObject::BMAssignment), operatorType(myOpType)
{
        assert(myVariable->getDomain() == myValue->getDomain());
        variable = myVariable;
        value = myValue;
}


BaseModelAssignment::BaseModelAssignment(BaseModelAssignment const &other)
: BaseModelObject(other)
{
        operatorType = other.operatorType;
        variable = other.variable;
        value = other.value;
}


BaseModelAssignment::~BaseModelAssignment()
{
        BaseModelAssignment::destroy();
}


char const * BaseModelAssignment::operatorToSymbolString(OperatorType op)
{
        switch(op){
        case EqualTo:
                return "=";
        case NotEqualTo:
                return "!=";
        case GreaterThan:
                return ">";
        case GreaterThanOrEqualTo:
                return ">=";
        case LessThan:
                return "<";
        case LessThanOrEqualTo:
                return "<=";
        default:
                return "??? Invalid Operator ???";
        }
}


BaseModelAssignment::OperatorType
BaseModelAssignment::symbolStringToOperator(char const * op)
{
        switch( op[0] )
        {
        case '=':
                if( op[1] == '\0' )
                        return EqualTo;
                break;
        case '!':
                if( op[1] == '=' && op[2] == '\0' )
                        return NotEqualTo;
                break;
        case '>':
                if( op[1] == '\0' )
                        return GreaterThan;
                else if( op[1] == '=' && op[2] == '\0' )
                        return GreaterThanOrEqualTo;
                break;
        case '<':
                if( op[1] == '\0' )
                        return LessThan;
                else if( op[1] == '=' && op[2] == '\0' )
                        return LessThanOrEqualTo;
                break;
        default:
                break;
        }
        String error("Invalid Assignment Operator: '");
        error += op;
        error += '\'';
        throw RuntimeException( error, __FILE__, __LINE__ );
}


BaseModelVariable const * BaseModelAssignment::getVariable() const
{
        return variable;
}


BaseModelValue const * BaseModelAssignment::getValue() const
{
        return value;
}


BaseModelAssignment::OperatorType BaseModelAssignment::getOperator() const
{
        return operatorType;
}


bool BaseModelAssignment::assignmentHolds(BaseModelValue const &variableValue) const
{
        switch(operatorType){
        case EqualTo:
                return variableValue == *value;
        case NotEqualTo:
                return variableValue != *value;
        case LessThan:
                return variableValue < *value;
        case LessThanOrEqualTo:
                return variableValue <= *value;
        case GreaterThan:
                return variableValue > *value;
        case GreaterThanOrEqualTo:
                return variableValue >= *value;
        default:
                fprintf(stderr, "Error, Assignment Operator Type is invalid: %d\n",
                                                operatorType);
                return false;
        }
}


bool BaseModelAssignment::assignmentHolds(double variableValue) const
{
        switch(operatorType){
        case EqualTo:
                return variableValue == value->getDouble();
        case NotEqualTo:
                return variableValue != value->getDouble();
        case LessThan:
                return variableValue < value->getDouble();
        case LessThanOrEqualTo:
                return variableValue <= value->getDouble();
        case GreaterThan:
                return variableValue > value->getDouble();
        case GreaterThanOrEqualTo:
                return variableValue >= value->getDouble();
        default:
                fprintf(stderr, "Error, Assignment Operator Type is invalid: %d\n",
                                                operatorType);
                return false;
        }
}


BaseModelAssignment const & BaseModelAssignment::operator =(BaseModelAssignment const & other)
{
        copy(other);
        return other;
}


bool BaseModelAssignment::operator ==(BaseModelAssignment const & other) const
{
        if(this == &other)
                return true;
        if(operatorType != other.operatorType)
                return false;
        if((*value) != (*other.value))
                return false;
        return (*variable) == (*other.variable);
}


bool BaseModelAssignment::operator !=(BaseModelAssignment const & other) const
{
        return !BaseModelAssignment::operator ==(other);
}


#ifndef EMBEDDED

void BaseModelAssignment::print(ostream &out) const
{
        char const * startString, * opString, * endString;

        startString = "(";
        endString = ")";
        switch(operatorType){
        case Negative:
                startString = "(NOT (";
                endString = "))";
        case Positive:
                opString = "=";
                break;
        case GreaterThan:
                opString = ">";
                break;
        case GreaterThanOrEqualTo:
                opString = ">=";
                break;
        case LessThan:
                opString = "<";
                break;
        case LessThanOrEqualTo:
                opString = "<=";
                break;
        default:
                opString = "<Unknown Operator>";
                break;
        }

        out << startString;
        if(NULL == variable)
                out << "NULL Variable";
        else
                out << variable->getName();
        out << ' ' << opString << ' ';
        if(NULL == value)
                out << "NULL Value";
        else
                out << value->getName();
        out << endString;
}

#endif


void BaseModelAssignment::destroy()
{
        // Nothing needs to be done, might as well set the variable & value to NULL
        variable = NULL;
        value = NULL;
}


int BaseModelAssignment::copy(BaseModelAssignment const &other)
{
        operatorType = other.operatorType;
        variable = other.variable;
        value = other.value;
        return 0;
}

---