/Users/fpy/titan-1-5-MBARI/Mers/Models/Base/unit-tests/BMHelper.h

//
// 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
//

#ifndef BM_HELPER_HEADER_FILE
#define BM_HELPER_HEADER_FILE

#include <tut.h>
#include <Mers/Models/Base/BaseModelDomainArray.h>
#include <Mers/Models/Base/BaseModelVariable.h>
#include <Mers/Models/Base/BaseModelVariableArray.h>
#include <Mers/Models/Base/BaseModelSentence.h>
#include <Mers/Models/Base/BaseModelAssignmentArray.h>
#include <vector>

namespace Mers {
namespace Models {
namespace Base {
        class BaseModel;
}
}
}

namespace tut {

        class BMHelper
        {
        public:
                BMHelper();

                virtual ~BMHelper();

        protected:
                struct BMDomainEntry {
                        char const * name;
                        char const ** values;
                };

                struct BMVariableEntry {
                        char const * name;
                        unsigned int domainIndex;
                        Mers::Models::Base::BaseModelVariable::VariableType varType;
                };
                
                static Mers::Models::Base::BaseModelDomain *
                        loadDomain(const struct BMDomainEntry * domainData, unsigned int index);

                static Mers::Models::Base::BaseModelVariable * loadVariable(
                        Mers::Models::Base::BaseModelDomainArray &domains, 
                        const struct BMVariableEntry * variableData, unsigned int index);

                static void loadDomainData(unsigned int numDomains, 
                        const struct BMDomainEntry * domainData,
                        Mers::Models::Base::BaseModelDomainArray &doms);

                static void loadVariableData(unsigned int numVariables,
                        const struct BMVariableEntry * variables,
                        Mers::Models::Base::BaseModelDomainArray &doms,
                        Mers::Models::Base::BaseModelVariableArray &vars);

                static void loadModelData( unsigned int numDomains,
                        const struct BMDomainEntry * domainData,
                        unsigned int numVariables,
                        const struct BMVariableEntry * variableData,
                        Mers::Models::Base::BaseModel &model );

                static void getVariableSubset(unsigned int numSubsetVars,
                        const unsigned int * subsetVarData,
                        Mers::Models::Base::BaseModelVariableArray &allVars,
                        Mers::Models::Base::BaseModelVariableArray &subsetVars);

                static void loadClause(unsigned int numAssignments,
                        const int clauseData[],
                        Mers::Models::Base::BaseModelVariableArray &variables,
                        Mers::Models::Base::BaseModelClause &clause);

                template<int n>
                static void loadClauses(
                        unsigned int numClauses,
                        const int clauseData[][n],
                        Mers::Models::Base::BaseModelVariableArray &vars,
                        Mers::Models::Base::BaseModelClauseArray &clauses)
                {
                        for(unsigned int i = 0; i < numClauses; ++i) {
                                Mers::Models::Base::BaseModelClause * clause =
                                        new Mers::Models::Base::BaseModelClause(
                                        Mers::Models::Base::BaseModelClause::DISJUNCTIVE, true);

                                loadClause(n, clauseData[i], vars, *clause);
                                clauses.pushBack(clause);
                        }
                }

                template<int n>
                static void loadAssignments(std::vector<Mers::Models::Base::BaseModelAssignmentArray *> &assignments,
                        unsigned int numAssignments, const unsigned int assignmentsData[][n],
                        Mers::Models::Base::BaseModelVariableArray & variables)
                {
                        const unsigned int noVal = (unsigned int) -1;

                        for(unsigned int a = 0; a < numAssignments; a++)
                        {
                                Mers::Models::Base::BaseModelAssignmentArray * asgArray = 
                                        new Mers::Models::Base::BaseModelAssignmentArray(true);

                                for(unsigned int v = 0; v < n; v++)
                                {
                                        unsigned int valIndex = assignmentsData[a][v];
                                        if(valIndex != noVal) {
                                                //std::cout << std::endl << "LoadAssignment[" << a << "][" << v << "] = " << valIndex << "; DomLength=" << variables[v]->getDomain()->getLength() << std::endl;
                                                //std::cout << *(variables[v]) << std::endl;
                                                //std::cout << *(variables[v]->getDomain()) << std::endl;
                                                ensure("BMHelper::loadAssignments: "
                                                                         "Variable Index is within range",
                                                        v < variables.getLength());
                                                ensure("BMHelper::loadAssignments: Value Index is within range",
                                                        valIndex < variables[v]->getDomain()->getLength());

                                                Mers::Models::Base::BaseModelVariable const * var = variables[v];
                                                Mers::Models::Base::BaseModelValue const * val = var->getValue(valIndex);
                                                Mers::Models::Base::BaseModelAssignment * asg = new Mers::Models::Base::BaseModelAssignment(var, val);

                                                asgArray->pushBack(asg);
                                        }
                                }
                                assignments.push_back(asgArray);
                        }
                }
        };

}

#endif

---