/Users/fpy/titan-1-5-MBARI/Mers/Models/Base/BaseModel.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
//

#if !defined(AFX_BASEMODEL_H__3DD1B58F_2B14_4A24_AEDC_ED2AD24BBA2A__INCLUDED_)
#define AFX_BASEMODEL_H__3DD1B58F_2B14_4A24_AEDC_ED2AD24BBA2A__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <Mers/Utils/Lang/BaseModelObject.h>
#include "BaseModelDomainArray.h"
#include "BaseModelVariableArray.h"
#include "BaseModelAssignment.h"
#include <Mers/Utils/Lang/String.h>

namespace Mers {
        namespace Models {
                namespace Base {

                        class BaseModel : public Mers::Utils::Lang::BaseModelObject
                        {
                        public:
                                //-----------------------------------------
                                // Constructors
                                //-----------------------------------------

                                BaseModel(char const * myName = "Basic Model");

                                //-----------------------------------------
                                // Copy constructors
                                //-----------------------------------------

                                BaseModel(BaseModel const &other);

                                //-----------------------------------------
                                // Destructors
                                //-----------------------------------------

                                virtual ~BaseModel();

                                //-----------------------------------------
                                // Functions
                                //-----------------------------------------

                                int setName(char const * newName);
                                char const * getName() const;

                                int addDomain(char const * domainName, BaseModelValueArray &values,
                                                                                        BaseModelDomain::DomainType domainType = BaseModelDomain::Normal);
                                int addDomain(BaseModelDomain * domain);

                                BaseModelDomain * getDomain(unsigned int domainUID);
                                BaseModelDomain const * getDomain(unsigned int domainUID) const;
                                BaseModelDomain * getDomain(char const * domainName);
                                BaseModelDomain const * getDomain(char const * domainName) const;

                                BaseModelDomainArray * getDomains();
                                BaseModelDomainArray const * getDomains() const;

                                virtual int addVariable(char const * variableName, 
                                                                                                                                BaseModelVariable::VariableType variableType, BaseModelDomain * domain);
                                virtual int addVariable(BaseModelVariable * variable);

                                BaseModelVariable * getVariable(unsigned int variableUID);
                                BaseModelVariable const * getVariable(unsigned int variableUID) const;
                                BaseModelVariable * getVariable(char const * variableName);
                                BaseModelVariable const * getVariable(char const * variableName) const;

                                BaseModelVariableArray * getVariables();
                                BaseModelVariableArray const * getVariables() const;

                                BaseModelAssignment * getAssignment(char const * variableName, char const * valueName,
                                                                                                                                                                                BaseModelAssignment::OperatorType opType = BaseModelAssignment::Positive) const;

                                void clear();

                                //-----------------------------------------
                                // Operators
                                //-----------------------------------------

                                bool operator==( BaseModel const &other ) const;

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

                                BaseModel const & operator =(BaseModel const &other);

#ifndef EMBEDDED

                                virtual void print(std::ostream &out) const;
#endif

                        protected:
                                //-----------------------------------------
                                // Functions
                                //-----------------------------------------

                                virtual BaseModelAssignment * newAssignment(BaseModelVariable const * variable,
                                                                                                                                                                                                                BaseModelValue const * value, BaseModelAssignment::OperatorType opType) const;

                                virtual BaseModelVariable * newVariable(char const * variableName, unsigned int variableUID, 
                                                                                                                                                                                                BaseModelVariable::VariableType variableType, BaseModelDomain * domain);

                                virtual BaseModelDomain * newDomain(char const * domainName, unsigned int domainUID, 
                                                                                                                                                                                BaseModelValueArray &values, BaseModelDomain::DomainType domainType);

                                virtual BaseModelDomainArray * newDomainArray(BaseModelDomainArray const * other = NULL);
                                virtual BaseModelVariableArray * newVariableArray(BaseModelVariableArray const * other = NULL);

                                virtual void destroy();
                                virtual int copy(BaseModel const &other);

                        protected:
                                //-----------------------------------------
                                // Data
                                //-----------------------------------------

                                char * name;
                                BaseModelDomainArray * domains;
                                BaseModelVariableArray * variables;
                        };
                }
        }
}

#endif // !defined(AFX_BASEMODEL_H__3DD1B58F_2B14_4A24_AEDC_ED2AD24BBA2A__INCLUDED_)

---