/Users/fpy/titan-1-5-MBARI/Mers/Generators/BFIG/unit-tests/BFIGHelper.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.
//


#ifndef BFIG_HELPER_HEADER_FILE
#define BFIG_HELPER_HEADER_FILE

#include <tut.h>
#include <vector>
#include <Mers/Models/Base/unit-tests/BMHelper.h>
#include <Mers/Models/Base/BaseModelAssignmentArray.h>
#include <Mers/Models/Base/BaseModelVariableArray.h>
#include <Mers/Utils/Containers/IntegerArray.h>
#include <Mers/Generators/BFIG/BFIGVariable.h>

namespace tut {

        class BFIGHelper : public BMHelper
        {
        public:
                BFIGHelper();

                virtual ~BFIGHelper();

        protected:
                struct BFIGDomainEntry {
                        struct BMDomainEntry bmData;
                };

                struct BFIGVariableEntry {
                        bool registered;
                        struct BMVariableEntry bmData;
                        double const * probsOrCosts;
                };

                void initBFIGData(unsigned int numDomains, 
                        const struct BFIGDomainEntry * domains,
                        unsigned int numVariables, 
                        const struct BFIGVariableEntry * variables) throw();

                void initBFIGVariables(bool isProbabilities) throw();

                template<int n>
                void loadAssignments(std::vector<Mers::Models::Base::BaseModelAssignmentArray *> &assignments,
                        unsigned int numAssignments, const unsigned int assignmentsData[][n])
                {
                        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) {
                                                ensure("BFIGHelper::loadAssignments: "
                                                                         "Variable Index is within range",
                                                        v < mBFIGVariables.getLength());
                                                ensure("BFIGHelper::loadAssignments: Value Index is within range",
                                                        valIndex < mBFIGVariables[v]->getDomain()->getLength());

                                                Mers::Models::Base::BaseModelVariable const * var = mBFIGVariables[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);
                        }
                }

                void loadAssignments(std::vector<Mers::Generators::BFIG::BFIGAssignment *>
                                &assignments, const unsigned int assignmentsData[]);

                void loadAssignments(std::vector<Mers::Generators::BFIG::BFIGAssignment const *>
                        &assignments, const unsigned int assignmentsData[]);

                void loadConstraints(std::vector<Mers::Generators::BFIG::BFIGConstraint *>
                        &constraints, const unsigned int constraintValues[],
                        const bool constraintParity[]);

                void loadConstraints(std::vector<Mers::Generators::BFIG::BFIGConstraint const *>
                        &constraints, const unsigned int constraintValues[],
                        const bool constraintParity[]);

                template<class T>
                void convertVector(std::vector<const T *> &constVect, const std::vector<T *> &vect)
                {
                        unsigned int size = vect.size();
                        constVect.resize(size);
                        for(unsigned int v = 0; v < size; v++) {
                                constVect[v] = vect[v];
                        }
                }

        protected:
                Mers::Models::Base::BaseModelVariableArray mBFIGVariables;
                Mers::Models::Base::BaseModelVariableArray mAllVariables;
                Mers::Models::Base::BaseModelDomainArray mDomains;
                Mers::Utils::Containers::IntegerArray mValueMap;
                std::vector<double> mProbabilities;
                std::vector<Mers::Generators::BFIG::BFIGVariable *> mBFIGVarList;
        };


}

#endif

---