/Users/fpy/titan-1-5-MBARI/Mers/Models/Base/BaseModel.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 "BaseModel.h"
#include "BaseModelUtils.h"
#include "BaseModelDoubleDomain.h"
#include "BaseModelIntegerDomain.h"
#include "BaseModelStringDomain.h"
#include <cstdio>


using namespace Mers::Models::Base;
using std::ostream;
using std::endl;

// Construction/Destruction

BaseModel::BaseModel(char const * myName) : BaseModelObject(BaseModelObject::BMModel)
{
        name = NULL;
        setName(myName);
        domains = newDomainArray();
        if(!domains){
                fprintf(stderr, "Error, Model %s unable to create a domain array\n", myName);
        }
        variables = newVariableArray();
        if(!variables){
                fprintf(stderr, "Error, Model %s unable to create a variable array\n", myName);
        }
}


BaseModel::BaseModel(BaseModel const &other)
: BaseModelObject(other), name( NULL ), domains( NULL ), variables( NULL )
{
        copy( other );
}


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


int BaseModel::setName(char const * newName)
{
        return BaseModelUtils::setName(name, newName);
}


char const * BaseModel::getName() const
{
        return name;
}


int BaseModel::addDomain(char const * domainName, BaseModelValueArray &values,
                          BaseModelDomain::DomainType domainType)
{
        BaseModelDomain * domain;
        domain = newDomain(domainName, domains->getLength(), values, domainType);
        
        if(NULL == domain){
                fprintf(stderr, "Unable to create a new domain object\n");
                return 1;
        }

        // if the values list isn't empty delete everything in it (it means we failed
        // to add the new domain object)
        values.makeEmpty();

        return addDomain(domain);
}


int BaseModel::addDomain(BaseModelDomain * domain)
{
        int ret;
        ret = domains->pushBack(domain);
        domain->setUID( domains->getLength() - 1 );
        // if addition failed, delete our object and return the error code
        if(ret != 0 && domain != NULL){
                delete domain;
        }
        return ret;
}


BaseModelDomain * BaseModel::getDomain(unsigned int domainUID)
{
        return domains->operator [](domainUID);
}


BaseModelDomain const * BaseModel::getDomain(unsigned int domainUID) const
{
        return domains->operator [](domainUID);
}


BaseModelDomain * BaseModel::getDomain(char const * domainName)
{
        return domains->find(domainName);
}


BaseModelDomain const * BaseModel::getDomain(char const * domainName) const
{
        return domains->find(domainName);
}


BaseModelDomainArray * BaseModel::getDomains()
{
        return domains;
}


BaseModelDomainArray const * BaseModel::getDomains() const
{
        return domains;
}


int BaseModel::addVariable(char const * variableName, 
        BaseModelVariable::VariableType variableType, BaseModelDomain * domain)
{
        BaseModelVariable * variable;
        variable = newVariable(variableName, variables->getLength(), variableType, domain);
        
        if(NULL == variable){
                fprintf(stderr, "Unable to create a new variable object\n");
                return 1;
        }

        return addVariable(variable);
}


int BaseModel::addVariable(BaseModelVariable * variable)
{
        int ret;
        ret = variables->pushBack(variable);
        // if addition failed, delete our object and return the error code
        if(FAILED(ret) && variable != NULL){
                delete variable;
        }
        return ret;
}


BaseModelVariable * BaseModel::getVariable(unsigned int variableUID)
{
        return variables->operator [](variableUID);
}


BaseModelVariable const * BaseModel::getVariable(unsigned int variableUID) const
{
        return variables->operator [](variableUID);
}


BaseModelVariable * BaseModel::getVariable(char const * variableName)
{
        return variables->find(variableName);
}


BaseModelVariable const * BaseModel::getVariable(char const * variableName) const
{
        return variables->find(variableName);
}


BaseModelVariableArray * BaseModel::getVariables()
{
        return variables;
}


BaseModelVariableArray const * BaseModel::getVariables() const
{
        return variables;
}


BaseModelAssignment * BaseModel::getAssignment(char const * variableName,
        char const * valueName, BaseModelAssignment::OperatorType opType) const
{
        BaseModelVariable const * variable;
        BaseModelValue const * value;

        variable = getVariable(variableName);

        if(NULL == variable){
                fprintf(stderr, "Error, unable to find the variable \"%s\"\n", variableName);
                return NULL;
        }

        value = variable->getValue(valueName);
        if(NULL == value){
                fprintf(stderr, "Error, unable to find the value \"%s\"\n", valueName);
                fprintf(stderr, "  in the variable \"%s\"\n", variableName);
                return NULL;
        }

        BaseModelAssignment * assignment;
        // should we just return newAssignment? or print an error message?
        assignment = newAssignment(variable, value, opType);
        
        if(NULL == assignment){
                fprintf(stderr, "Unable to create a new assignment object\n");
                return NULL;
        }

        return assignment;
}


void BaseModel::clear()
{
        destroy();
}


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


bool BaseModel::operator ==(BaseModel const &other) const
{
        // Compare the three things stored in this model.
        return (*domains == *other.domains) && (*variables == *other.variables) &&
                strcmp( name, other.name) == 0;
}


#ifndef EMBEDDED

void BaseModel::print(ostream &out) const
{
        char const * localName = name;

        if(NULL == localName)
                localName = "NULL Name";

        out << "Model \"" << localName << "\" {"<< endl;
        out << "Domains(" << localName << ") {" << endl << domains 
                << endl << "} Domains(" << localName << ")" << endl << endl;
        out << "Variables(" << localName << ") {" << endl << variables 
                << endl << "} Variables(" << localName << ")" << endl << endl;
        out << "} Model(" << localName << ")" << endl;
}

#endif


BaseModelAssignment * BaseModel::newAssignment(BaseModelVariable const * variable,
        BaseModelValue const * value, BaseModelAssignment::OperatorType opType) const
{
        return new BaseModelAssignment(variable, value, opType);
}


BaseModelVariable * BaseModel::newVariable(char const * variableName, 
        unsigned int variableUID, BaseModelVariable::VariableType variableType,
        BaseModelDomain * domain)
{
        return new BaseModelVariable(variableName, domain, variableType, variableUID);
}


BaseModelDomain * BaseModel::newDomain(char const * domainName, unsigned int domainUID, 
        BaseModelValueArray &values, BaseModelDomain::DomainType domainType)
{
        BaseModelDomain * domain;
        switch(domainType){
        case BaseModelDomain::Normal:
                domain = new BaseModelDomain(domainName, true, domainUID);
                break;
        case BaseModelDomain::Double:
                domain = new BaseModelDoubleDomain(domainName, true, domainUID);
                break;
        case BaseModelDomain::Integer:
                domain = new BaseModelIntegerDomain(domainName, true, domainUID);
                break;
        case BaseModelDomain::String:
                domain = new BaseModelStringDomain(domainName, true, domainUID);
                break;
        default:
                fprintf(stderr, "BaseModel Error, invalid domain type: %d\n", (int) domainType);
                return NULL;
        }

        if(NULL == domain)
                return NULL;
        
        for(unsigned int x = 0; x < values.getLength(); x++){
                if(FAILED(domain->pushBack(values[x]))){
                        // this will get deleted by pushBack since it failed
                        values[x] = NULL;
                        fprintf(stderr, "Error, unable to add another value to the domain\n");
                        fprintf(stderr, "%s due to lack of memory\n", domainName);
                        values.makeEmpty();
                        domain->makeEmpty();
                        delete domain;
                        return NULL;
                }
                values[x] = NULL;
        }

        values.makeEmpty();
        return domain;
}


BaseModelDomainArray * BaseModel::newDomainArray(BaseModelDomainArray const * other)
{
        if(NULL == other)
                return new BaseModelDomainArray(true);
        else
                return new BaseModelDomainArray(*other);
}


BaseModelVariableArray * BaseModel::newVariableArray(BaseModelVariableArray const * other)
{
        if(NULL == other)
                return new BaseModelVariableArray(true);
        else
                return new BaseModelVariableArray(*other);
}


void BaseModel::destroy()
{
        if(NULL != domains){
                domains->makeEmpty();
                delete domains;
                domains = NULL;
        }

        if(NULL != variables){
                variables->makeEmpty();
                delete variables;
                variables = NULL;
        }

        if(NULL != name)
                delete[] name;
        name = NULL;
}


int BaseModel::copy(BaseModel const &other)
{
        BaseModel::destroy();
        domains = newDomainArray(other.domains);
        if(NULL == domains || domains->getLength() != other.domains->getLength()){
                fprintf(stderr, "Error, unable to copy the domains\n");
                fprintf(stderr, "from the model %s\n", other.name);
                return 1;
        }

        variables = newVariableArray(other.variables);
        if(NULL == variables || variables->getLength() != other.variables->getLength()){
                fprintf(stderr, "Error, unable to copy the variables\n");
                fprintf(stderr, "from the model %s\n", other.name);
                return 2;
        }

        // Note that this copies the domains of the other object.  We need
        // to transfer the domains to this object.
        for( unsigned int i = 0; i < variables->getLength(); ++i ) {
                // Get the variable
                BaseModelVariable * var = (*variables)[i];
                // Get the domain UID that we want.
                unsigned int uid = var->getDomain()->getUID();
                var->setDomain( getDomain( uid ) );
        }

        if(FAILED(setName(other.name))){
                fprintf(stderr, "Warning, model unable to copy the name\n");
                fprintf(stderr, "from the model %s\n", other.name);
                return -1;
        }
        return 0;
}

---