AltaricaModel.hh

Go to the documentation of this file.

#ifndef  __DIADES__ALTARICA__ALTARICAMODEL__HH
#define  __DIADES__ALTARICA__ALTARICAMODEL__HH

#include<diades/utils/Exceptions.hh>
#include<diades/altarica/Domains.hh>
#include<diades/altarica/Value.hh>
#include<diades/altarica/Type.hh>
#include<diades/altarica/ParameterDecl.hh>
#include<diades/altarica/VariableDecl.hh>
#include<diades/altarica/NodeDecl.hh>
#include<diades/altarica/Transition.hh>
#include<diades/altarica/Expression.hh>
#include<diades/altarica/ExpressionFactory.hh>
//#include"Variable.hh"
//#include"Node.hh"

namespace Diades
{
  namespace Altarica
  {


        class AltaricaModel
        {

        public:
          typedef reference_wrapper<AltaricaModel> Reference;
          typedef reference_wrapper<AltaricaModel const> ConstReference;
          typedef AltaricaModel * Pointer;
          typedef const AltaricaModel * ConstPointer;


          
        private:
         
          mutable TypeFactory   _typeFactory;
          mutable ValueFactory  _valueFactory;
          DomainFactory _domainFactory;
          VariableDeclFactory  _varDeclFactory;


          vector<VariableDecl::Reference> _mainVariableDecl;
          
          NodeDeclFactory  _nodeDeclFactory;
          mutable EventDeclFactory _eventFactory;

          ExpressionFactory _expressionFactory;
          //  VariableFactory _varFactory;
          ParameterDeclFactory _paramDeclFactory;
        public:
          typedef vector<NodeDecl::Reference> NodeDecls;
          typedef NodeDecls::const_iterator  NodeDeclIterator;
          typedef unordered_map<Identifier,Domain::ConstReference> DomainDictionary;
          typedef unordered_map<Identifier,Value::ConstReference> ConstantDictionary;
          typedef unordered_map<Identifier,NodeDecl::Reference> NodeDeclDictionary;

        private:

          DomainDictionary _domainDictionary;

          vector<Domain::ConstReference> _globalDomains;


          
          NodeDecls   _nodeDecls;
          vector<NodeDecl::Reference> _mainNodeDecl;

          // Node _main;
          NodeDeclDictionary _nodeDeclOfLabel;

          Identifier _name;

          ConstantDictionary _constantDictionary;

          unsigned typeIndex(Domain::DomainType type) const;
        

        public:
          typedef Utils::Exception<AltaricaModel> Exception;
          static string typeName() { return "Diades::Altarica::AltaricaModel"; }


        public:

          const ConstantDictionary & constants() const
          {
                return _constantDictionary;
          }

          void addConstant(const Identifier & name, const Value & value)
          {
                always_require(Exception, getConstant(name).isNull(),"addConstant: such a constant already exists.");
                _constantDictionary.insert(make_pair(name,Value::ConstReference(value)));
          }


          const Value & getConstant(const Identifier & name) const
          {
                ConstantDictionary::const_iterator it = _constantDictionary.find(name);
                if(it != _constantDictionary.end())
                  {
                        return it->second;
                  }
                return nullValue();
          }
          
          

          

          AltaricaModel(const Identifier & name);



          ~AltaricaModel();
          


          

          //bool valid() const;
        


          const Identifier & name() const
          {
                return _name;
          }


          bool operator==(const AltaricaModel & model) const
          {
                return this == &model;
          }
          
          bool operator!=(const AltaricaModel & model) const
          {
                return !(model==(*this));
          }
          
          
          
          const Type & nullType() const
          {
                return _typeFactory.nullType();
          }

          const Type & getBoolean() const
          {
                return _typeFactory.getBoolean();
          }
          const Type & getIdentifier() const 
          {
                return _typeFactory.getIdentifier();
          }
          
          const Type & getInteger() const 
          {
                return _typeFactory.getInteger();
          }
          
          const Type & getStructureType(const Type::StructureFields & fields) const
          {
                try
                  {
                        return _typeFactory.getStructureType(fields);
                  }
                catch(exception & e)
                  {
                        throw(Exception("getStructureType failure",e));
                  }
                return nullType();
          }


          
          const Type & getArrayType(const Type & type,unsigned size) const
          {
                try
                  {
                        return _typeFactory.getArrayType(type,size);
                  }
                catch(exception & e)
                  {
                        throw(Exception("getArrayType failure",e));
                  }
                return nullType();
          }

          
        public:

          const Value & nullValue() const
          {
                return _valueFactory.nullValue();
          }
          
          const Value & getValue(const Identifier & value) const
          {
                try
                  {
                        return _valueFactory.getValue(value);
                  }
                catch(exception & e)
                  {
                        throw(Exception("getValue (identifier) failure",e));
                  }
                return nullValue();
          }
          
          const Value & getValue(bool value) const
          {
                return _valueFactory.getValue(value);
          }

          const Value & getValue(int value) const
          {
                return _valueFactory.getValue(value);
          }

          const Value & getValue(const Value::ArrayFields & array) const
          {
                try
                  {
                        return _valueFactory.getValue(array); 
                  }
                catch(exception & e)
                  {
                        throw(Exception("getValue (array) failure",e));
                  }
                return nullValue();
          }


          const  Value & getValue(const Value::StructureFields & structure) const
          {
                
                try
                  {
                        return _valueFactory.getValue(structure);
                  }
                catch(exception & e)
                  {
                        throw(Exception("getValue (structure) failure",e));
                  }
                return nullValue();
          }


        public:


          const Domain & getBooleans() const
          {
                return _domainFactory.getBooleans();
          }
          

          const Domain & getIntegers() const
          {
                return _domainFactory.getIntegers();
          }


          const Domain & newDomain(const Identifier & name, const Domain & associatedDomain, NodeDecl & node);

          const Domain &  newDomain(const Identifier & name, const Value & min,
                                                                const Value & max, NodeDecl & node);

        

 
          const Domain & newDomain(const Identifier & name, const ValueEnumeration & enumeration, NodeDecl & node);

          const Domain & newDomain(const Identifier & name, const map<Identifier,Domain::ConstReference> & structure, NodeDecl & node);

         const  Domain & newDomain(const Identifier & name, const Domain & domain, unsigned size, NodeDecl & node);



          const Domain & getDomain(const Identifier & name, NodeDecl & node);

          const Domain & getDomain(const NodeDecl & node);



          const Domain & nullDomain() const
          {
                return _domainFactory.nullDomain();
          }


          const vector<Domain::ConstReference> & domains() const
          {
                return _globalDomains;
          }

          

          
        public:


          VariableDecl & getNodeVariableDecl(const Identifier & id,
                                                                                 NodeDecl & node,
                                                                                 const set<Identifier> & attributes,
                                                                                 VariableDecl & scope)
          {
                try
                  {
                        return _varDeclFactory.getNodeVariableDecl(id,node,attributes,scope);
                  }
                catch(exception & e)
                  {
                        throw(Exception("getVariableDecl failure",e));
                  }
                return  nullVariableDecl();
          }




          
          VariableDecl & getVariableDecl(const Diades::Utils::Identifier & label,  NodeDecl::VarType type, const Domain & domain,
                                                                         const set<Identifier> & attributes,
                                                                         VariableDecl & scope)
          {
                
                try
                  {
                        return _varDeclFactory.getVariableDecl(label,domain,type,attributes,scope);
                  }
                catch(exception & e)
                  {
                        throw(Exception("getVariableDecl failure",e));
                  }
                return  nullVariableDecl();
          }

          const VariableDecl & nullVariableDecl() const
          {
                return _varDeclFactory.nullVariableDecl();
          }
          
          VariableDecl & nullVariableDecl()
          {
                return _varDeclFactory.nullVariableDecl();
          }



          const VariableDeclFactory & variableDeclFactory() const
          {
                return _varDeclFactory;
          }

          

        public:

          void noMainNodeDecl()
          {
                _mainNodeDecl.clear();
                _mainNodeDecl.push_back(nullNodeDecl());
                //_eventFactory.init();
                //_expressionFactory.init();
          }


          void setMainNodeDecl(const Identifier & name)
          {
                _mainNodeDecl.clear();
                _mainNodeDecl.push_back(getNodeDecl(name));
                _eventFactory.init();
                _expressionFactory.init();
          }

          bool containsNodeDecl(const Identifier & nodeName) const;

          NodeDecl & getNodeDecl(const Identifier & nodeName);


          NodeDecl & nullNodeDecl()
          {
                return _nodeDeclFactory.nullNodeDecl();
          }

          const NodeDecl & nullNodeDecl() const
          {
                return _nodeDeclFactory.nullNodeDecl();
          }

          
          
          unsigned numberOfNodeDecls() const 
          {
                return _nodeDecls.size();
          }


          NodeDeclIterator nodeDeclBegin() const
          {
                return _nodeDecls.begin();
          }
          
          NodeDeclIterator nodeDeclEnd() const
          {
                return  _nodeDecls.end();
          }

          

          typedef ExpressionFactory::ExprVector  ExprVector;

          const Expression & getVarExpression(const NodeDecl &  node, const VariableDecl & var) 
          {
                return _expressionFactory.getVarExpression(node,var);
          }

         


          const Expression & getIdentifierExpression(const NodeDecl &  node, const Identifier & id) 
          {
                return _expressionFactory.getIdentifierExpression(node,id);
          }

          const Expression & getBooleanExpression(Expression::Category category)
          {
                return _expressionFactory.getBooleanExpression(category);
          }


          const Expression & getIntegerExpression(int value) 
          {
                return _expressionFactory.getIntegerExpression(value);
          }


          const Expression & getIteExpression(const NodeDecl &  node, const Expression & ifE, const Expression & thenE, const Expression & elseE)
          {
                return _expressionFactory.getIteExpression(node,ifE,thenE,elseE);
          }


          const Expression & getCaseExpression(const NodeDecl &  node, const ExprVector & choices,
                                                                                   const ExprVector & expressions)
          {
                return _expressionFactory.getCaseExpression(node,choices,expressions);
          }



          const Expression & getBinaryExpression(const NodeDecl & node, Expression::Category category, const Expression & left, const Expression & right)
          {
                return _expressionFactory.getBinaryExpression(node,category,left,right);
          }

          const Expression & getUnaryExpression(const NodeDecl & node, Expression::Category category, const Expression & expr)
          {
                return _expressionFactory.getUnaryExpression(node,category,expr);
          }

          const Expression & getListExpression(const NodeDecl & node,Expression::Category category,  const ExprVector & expressions)
          {
                return _expressionFactory.getListExpression(node,category,expressions);
          }


          const Expression & getStructExpression(const NodeDecl &  node,const vector<Identifier> & identifiers,const ExprVector & expressions)  
          {
                return  _expressionFactory.getStructExpression(node,identifiers,expressions);
          }



          EventDecl & getEventDecl(const Identifier & id, NodeDecl & owner) 
          {
                always_require(Exception,owner.owner() == *this,"getEventDecl: the node declaration does belong to this model.");
                return _eventFactory.getEventDecl(owner,id);
          }
          
          const EventDecl & getEventDecl(const Identifier & id, const NodeDecl & owner) const
          {
                always_require(Exception,owner.owner() == *this,"getEventDecl: the node declaration does belong to this model.");
                return _eventFactory.getEventDecl(owner,id);
          }
          
          const EventDecl & nullEventDecl() const
          {
                return _eventFactory.nullEventDecl();
          }
          EventDecl & nullEventDecl()
          {
                return _eventFactory.nullEventDecl();
          }
        
          

          //  Node & getRootNode();       
          //const Node & getRootNode() const;
          //Node & getNode(const string & fullname );     
          //const Node & getRootNode(const string & fullname) const;

          const VariableDecl & mainVariableDecl() const  
          {
                return _mainVariableDecl[0];
          }

          VariableDecl & mainVariableDecl()   
          {
                return _mainVariableDecl[0];
          }

          
          
          
          const NodeDecl & mainNodeDecl() const  
          {
                return _mainNodeDecl[0];
          }
          NodeDecl & mainNodeDecl()   
          {
                return _mainNodeDecl[0];
          }


          const ParameterDecl & getParameterDecl(const Identifier & name,
                                                                                         const Domain & domain,
                                                                                         NodeDecl & node)
          {
                always_require(Exception,!name.str().empty(), "getParameterDecl: the name is empty.");
                always_require(Exception,!domain.isNull(),"getParameterDecl: the domain is null.");
                return _paramDeclFactory.getParameterDecl(name,domain,node);
          }

          const ParameterDecl & nullParameterDecl() const
          {
                return _paramDeclFactory.nullParameterDecl();
          }
        };

  };
};

#endif