/Users/fpy/titan-1-5-MBARI/Mers/Models/Base/unit-tests/BMHelper.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 "BMHelper.h"
#include <Mers/Models/Base/BaseModel.h>


using namespace tut;
using Mers::Models::Base::BaseModelVariable;
using Mers::Models::Base::BaseModelVariableArray;
using Mers::Models::Base::BaseModelValue;
using Mers::Models::Base::BaseModelValueArray;
using Mers::Models::Base::BaseModelDomain;
using Mers::Models::Base::BaseModelDomainArray;
using Mers::Models::Base::BaseModelClause;
using Mers::Models::Base::BaseModelAssignment;
using Mers::Models::Base::BaseModel;


BMHelper::BMHelper()
{

}


BMHelper::~BMHelper()
{

}


BaseModelDomain *
BMHelper::loadDomain(const struct BMDomainEntry * domainData, 
                                                                                                        unsigned int index)
{
        ensure("Domain data is non-null", domainData != NULL);

        bool ownerFlag = true;

        BaseModelDomain * domain = 
                new BaseModelDomain(domainData->name, ownerFlag, index);

        char const * const * domainValues = domainData->values;

        ensure("Domain is non-empty", domainValues != NULL);

        unsigned int v = 0;
        while(domainValues[v] != NULL) {
                domain->pushBack(new BaseModelValue(domainValues[v++]));
        }
        return domain;
}


BaseModelVariable * 
BMHelper::loadVariable(BaseModelDomainArray &domains, 
        const struct BMVariableEntry * variableData, unsigned int index)
{
        ensure("Variable data is non-null", variableData != NULL);

        ensure("Variable domain index is in range", 
                                 variableData->domainIndex < domains.getLength());

        ensure("Variable name is non-null", variableData->name != NULL);

        BaseModelVariable * variable = 
                new BaseModelVariable(variableData->name,
                                                                                                        domains[variableData->domainIndex],
                                                                                                        variableData->varType,
                                                                                                        index);
        return variable;
}


void BMHelper::loadDomainData(unsigned int numDomains, 
        const struct BMDomainEntry * domains,
        BaseModelDomainArray &doms)
{
        for(unsigned int d = 0; d < numDomains; d++) {
                BaseModelDomain * domain = loadDomain(domains + d, d);

                doms.pushBack(domain);
        }
}


void BMHelper::loadVariableData(unsigned int numVariables,
        const struct BMVariableEntry * variables,
        BaseModelDomainArray &doms, BaseModelVariableArray &vars)
{
        // Load our Variables
        for(unsigned int v = 0; v < numVariables; v++) {
                BaseModelVariable * variable = loadVariable(doms, variables + v, v);

                vars.pushBack(variable);
        }
}


void BMHelper::loadModelData(
        unsigned int numDomains, const struct BMDomainEntry * domainData,
        unsigned int numVariables, const struct BMVariableEntry * variableData,
        Mers::Models::Base::BaseModel &model )
{
        ensure("Domain data is non-null", domainData != NULL);
        ensure("Variable data is non-null", variableData != NULL);

        // Load our domains.
        for( unsigned int d = 0; d < numDomains; ++d ) {
                // Create a set of values
                char const * const * domainValues = domainData[d].values;

                // Load our values
                BaseModelValueArray values( false );
                unsigned int v = 0;
                while(domainValues[v] != NULL) {
                        values.pushBack(new BaseModelValue(domainValues[v++]));
                }

                // Add it to the model.
                model.addDomain( domainData[d].name, values );
        }

        // Load our variables.
        for( unsigned int v = 0; v < numVariables; ++v ) {
                ensure( "Variable domain index is in range", 
                        variableData[v].domainIndex < model.getDomains()->getLength() );

                ensure( "Variable name is non-null", variableData[v].name != NULL );

                model.addVariable( variableData[v].name, variableData[v].varType,
                        model.getDomain( variableData[v].domainIndex ) );
        }
}


void BMHelper::getVariableSubset(unsigned int numSubsetVars,
        const unsigned int * subsetVarData,
        BaseModelVariableArray &allVars, BaseModelVariableArray &subsetVars)
{
        // Load each variable into the subsetVars.
        for(unsigned int i = 0; i < numSubsetVars; ++i) {
                // Get the index of the desired variable.
                unsigned int index = subsetVarData[i];
                // Make sure its in range (can't be less than zero)
                ensure("Variable Subset index in range", index < allVars.size());
                // Add the variable to the subset list.
                subsetVars.pushBack(allVars[index]);
        }
}


void BMHelper::loadClause(unsigned int numAssignments,
        const int clauseData[],
        BaseModelVariableArray &variables, BaseModelClause &clause)
{
        // Load a single clause.
        for(unsigned int a = 0; a < numAssignments; a++)
        {
                // See if we include this literal - we include it only if it is non-zero.
                int asgData = clauseData[a];

                if(asgData != 0) {
                        // See if this literal is negative.
                        bool negative = asgData < 0;

                        // Load our value index.
                        unsigned int valIndex;
                        if(negative)
                                valIndex = (unsigned int)(-asgData - 1);
                        else
                                valIndex = (unsigned int)(asgData - 1);

                        // Verify our variable data.
                        ensure("BMHelper::loadClause: "
                                "Variable Index is within range",
                                a < variables.getLength());

                        // Load our variable.
                        BaseModelVariable const * var = variables[a];

                        // Verify our value data.
                        ensure("BMHelper::loadClause: Variable non-null", var != NULL);
                        ensure("BMHelper::loadClause: Domain non-null",
                                var->getDomain() != NULL);
                        ensure("BMHelper::loadClause: Value Index is within range",
                                valIndex < var->getDomain()->getLength());

                        // Get our value
                        BaseModelValue const * val = var->getValue(valIndex);

                        // Specify our parity.
                        BaseModelAssignment::OperatorType op;
                        if(negative)
                                op = BaseModelAssignment::Negative;
                        else
                                op = BaseModelAssignment::Positive;

                        // Create an assignment
                        BaseModelAssignment * asg = new BaseModelAssignment(var, val, op);

                        // Store our assignment
                        clause.pushBack(asg);
                }
        }
}

---