Node.hh

Go to the documentation of this file.

#ifndef __DIADES__ALTARICA__NODE__HH
#define __DIADES__ALTARICA__NODE__HH
#include <map>
#include <graph/Graph.hh>
#include <graph/NodeMap.hh>
#include <automata/ObservableComponent.hh>
#include "Transition.hh"
#include "Parameter.hh"
#include "Variable.hh"
#include "Event.hh"

namespace Diades
{
  namespace Altarica
  {

        typedef enum{Flow,State,NodeTypeVar} NodeVariableType;
  
        /****************************************************************************/    
        //class NodeInstance;

        class NodeData
        {

        private:
    
          unsigned _id;
          string   _name;
          unordered_map<Identifier,unsigned> _idParam;
          vector<Parameter> _param;
          vector<Transition> _trans;
          vector<Variable> _flowVar;
          vector<Variable> _stateVar;
          vector<Variable> _nodeVar;
          unordered_map<Identifier, Variable> _flowVarOfLabel;
          unordered_map<Identifier, Variable> _stateVarOfLabel;
          unordered_map<Identifier, Variable> _nodeVarOfLabel;
          set<Identifier>  _attributes;
          set<Event> _eventSet;
          unordered_map<Identifier,Event> _eventOfLabel;
          Diades::Graph::Graph _eventDag;
          Diades::Graph::NodeMap<Event> _events;
          vector<Expression *> _assertions;
          vector< NodeData *> _subNodes;
          vector< Identifier > _subNodesName;
          unordered_map<Identifier, NodeData *> _subNodesMap;
          list< vector< list<Identifier> > > _synchros;
          set<Assignment> _initialisations;
        
          NodeData(unsigned id):_id(id),_name("Invalid_but_non_empty_Altarica_Node"),
                                                        _idParam(),_param(),_flowVar(),_stateVar(),_nodeVar(),
                                                        _flowVarOfLabel(),_stateVarOfLabel(),_nodeVarOfLabel(),
                                                        _attributes(),_eventSet(),_eventOfLabel(),
                                                        _eventDag(),_events(_eventDag),_assertions(),_subNodes(),_subNodesMap(),_synchros(),
                                                        _initialisations(){}



          Event newEvent(const Identifier & id);


          Event getEvent(const Identifier & id) const
          {
                unordered_map<Identifier,Event>::const_iterator it = _eventOfLabel.find(id);
                if(it != _eventOfLabel.end())
                  {
                        return it->second;
                  }
                return Event();
          }
        
          void setPriorities(const set<Event> & lowEvents, const set<Event> & highEvents);

          void addAttribute(const Identifier & attribute);


          Variable addVariable(const Identifier & id, NodeVariableType type,  Domain domain, const set<Identifier> & attributes);

          Variable addStructureVariable(const Identifier & id, const set<Variable> & structure);

          void addAssertion(Expression * assertion)
          {
                _assertions.push_back(assertion);
          }

          
          void addParameter(const Identifier & id, Domain domain);


          void addTransition(const Transition & transition)
          {
                _trans.push_back(transition);
          }

          typedef vector<Transition>::const_iterator TransitionIterator;

          TransitionIterator transitionBegin() const
          {
                return _trans.begin();
          }


          TransitionIterator transitionEnd() const
          {
                return _trans.end();
          }

        
          Parameter  getParameter(const Identifier & id) const
          {
                unordered_map<Identifier,unsigned>::const_iterator it = _idParam.find(id);
                if(it == _idParam.end())
                  {
                        return Parameter();
                  }
                return _param[it->second];
          }
          Variable getVariable(const Identifier & id) const
          {
                Variable result;
                unordered_map<Identifier,Variable >::const_iterator it = _flowVarOfLabel.find(id);
                if(it == _flowVarOfLabel.end())
                  {
                        it = _stateVarOfLabel.find(id);
                        if(it != _stateVarOfLabel.end())
                          {
                                result =  it->second;
                          }
                        else
                          {
                                it = _nodeVarOfLabel.find(id);
                                if(it != _nodeVarOfLabel.end())
                                  {
                                        result = it->second;
                                  }
                          }
                  }
                else
                  {
                        result =  it->second;
                  }
                return result;
          }

          void addSubNode(const Identifier & name, const Node & nodeType);

        
          void addSyncVector(const vector< list<Identifier> > & paths);


          void addInitialisation(const Assignment & assignment);
        
        

        
          friend class AltaricaModel;
          friend class Node;
          friend class NodeInstance;
        };



        //      /****************************************************************************/

        
        class Node
        {
        public:
          typedef set<Event>::const_iterator EventIterator;
          typedef vector<Parameter>::const_iterator ParameterIterator;
          typedef vector<Transition>::const_iterator TransitionIterator;
          typedef vector<Variable>::const_iterator VariableIterator;
          typedef set<Identifier>::const_iterator AttributeIterator;
          typedef vector<Expression *>::const_iterator ExpressionPtrIterator;
        
        protected:
          NodeData * _data; 

          Node(NodeData * data):_data(data){}
          

        public:

          Node():_data(0) {}

          Node(const Node & node):_data(node._data) {}


          Node & operator=(const Node & node)
          {
                if(this != &node)
                  {
                        _data = node._data;
                  }
                return *this;
          }
          

          ~Node() {}
                 
          
          unsigned id() const { if(!valid()) { return 0;} return _data->_id; }

          bool valid() const { return _data != 0; }


          string name() const
          {
                if(!valid()) { return "Invalid_Altarica_Node"; }
                return _data->_name;
          }

          ExpressionPtrIterator assertionBegin() const
          {
                return _data->_assertions.begin();
          }
          ExpressionPtrIterator assertionEnd() const
          {
                return _data->_assertions.end();
          }

          unsigned numberOfSubNodes() const
          {
                return _data->_subNodes.size();
          }

          typedef vector<NodeData *>::size_type SubNodeIndex;
        
          SubNodeIndex subNodeFirst() const
          {
                return 0;
          }

          SubNodeIndex subNodeLast() const
          {
                return _data->_subNodes.size()-1;
          }

          Node getSubNode(SubNodeIndex index) const
          {
                return Node(_data->_subNodes[index]);
          }
        
          const string &  getSubNodeName(SubNodeIndex index) const
          {
                return _data->_subNodesName[index];
          }
        

          EventIterator eventBegin() const
          {
                return _data->_eventSet.begin();
          }


          EventIterator eventEnd() const         
          {
                return _data->_eventSet.end();
          }
          ParameterIterator parameterBegin() const
          {
                return _data->_param.begin();
          }


          ParameterIterator parameterEnd() const         
          {
                return _data->_param.end();
          }
        
          TransitionIterator transitionBegin() const
          {
                return _data->_trans.begin();
          }


          TransitionIterator transitionEnd() const       
          {
                return _data->_trans.end();
          }

        
          VariableIterator flowVariableBegin() const
          {
                return _data->_flowVar.begin(); 
          }

          VariableIterator flowVariableEnd() const
          {
                return _data->_flowVar.end();
          }
          unsigned numberOfFlowVariables() const
          {
                return _data->_flowVar.size();
          }
          VariableIterator nodeVariableBegin() const
          {
                return _data->_nodeVar.begin(); 
          }

          VariableIterator nodeVariableEnd() const
          {
                return _data->_nodeVar.end();
          }
          unsigned numberOfNodeVariables() const
          {
                return _data->_nodeVar.size();
          }


        
          VariableIterator stateVariableBegin() const
          {
                return _data->_stateVar.begin();
          }

          VariableIterator stateVariableEnd() const
          {
                return _data->_stateVar.end();
          }

          unsigned numberOfStateVariables() const
          {
                return _data->_stateVar.size();
          }

          AttributeIterator attributeBegin() const
          {
                return _data->_attributes.begin();
          }

          AttributeIterator attributeEnd() const
          {
                return _data->_attributes.end();
          }

          NodeData * data()  { return _data; } 

          Event getEvent(const Identifier & id) const
          {
                if(_data!=0)
                  {
                        return _data->getEvent(id);
                  }
                return Event();
          }


          Parameter  getParameter(const Identifier & id) const
          {
                Parameter result;
                if(_data!=0)
                  {
                        result = _data->getParameter(id);
                  }
                return result;
          }
          Variable getVariable(const Identifier & id) const
          {
                Variable result;
                if(_data!=0)
                  {
                        result = _data->getVariable(id);
                  }
                return result;
          }


          typedef set<Assignment>::const_iterator InitialisationIterator;

          InitialisationIterator initialisationBegin() const
          {
                return _data->_initialisations.begin();
          }


          InitialisationIterator initialisationEnd() const
          {
                return _data->_initialisations.end();
          }
        
        
          friend class Event;
          friend class NodeData;
          friend class Parameter;
          friend class Variable;
          friend class AltaricaModel;
          friend class NodeInstance;
        };

  
  };
};

#endif