ComponentType.hh

Go to the documentation of this file.

#ifndef COMPONENTTYPE_H_
#define COMPONENTTYPE_H_

#include<string>
#include<map>
#include<vector>
#include<stdexcept>
#include<diades/utils/Assertion.hh>
#include<iostream>

#include <diades/sdmdl/Formula.hh>
#include <diades/sdmdl/Variable.hh>
#include <diades/sdmdl/Event.hh>
#include <diades/sdmdl/Port.hh>
#include <diades/sdmdl/Rule.hh>

using namespace std;

namespace Diades
{
  namespace Sdmdl
  {
        
        class ComponentTypeInvalid : public runtime_error, public domain_error {
        public:
          ComponentTypeInvalid(const string& whatArg) : runtime_error(whatArg),  domain_error(whatArg){
                cerr << "EXCEPTION ComponentTypeInvalid -> " << whatArg << endl;
          }
        };
        


        class ComponentType
        {
        
        public:
          typedef VariableVector::const_iterator VariableIterator;
          typedef vector<Port *>::const_iterator PortIterator;
          typedef vector<Event *>::const_iterator EventIterator;
          typedef map<string,Formula::ConstReference>::const_iterator InvariantIterator;
          typedef vector<Rule *>::const_iterator RuleIterator;

        private:
          string labl;
        
        
          map<string, vector<Port *>::size_type > _mapInport; 
          vector<Port *> _inports;
        
          map<string, vector<Port *>::size_type> _mapOutport; 
          vector<Port *>  _outports;
        
          map<string, VariableVector::size_type > _mapVar;
          VariableVector _variables;
                
          map<string,vector<Event *>::size_type> _mapOutEvt;
          vector<Event *> _outputEvents;
        
          map<string,vector<Event *>::size_type> _mapInEvt;
          vector<Event *> _inputEvents;
        
          map<string,vector<Rule *>::size_type> _mapRule;
          vector<Rule *> _rules;
        
          map<string,Formula::ConstReference> _invariant;
        
          vector<Formula::ConstReference>  _globalInvariant;
          vector<Formula::ConstReference>  _stateInvariant;
          FormulaFactory * _factory;

        
        public:
          ComponentType();
          virtual ~ComponentType();
        
        
          // labels
          void setLabel(const string & label) { labl = label; }
          const string & label() const { return labl; }
        
          // creators
          Port &  createInputPort(const string & portLabel);
          Port &  createOutputPort(const string & portLabel);
          Port &  createInputPort(const string & portLabel, bool observable);
          Port &  createOutputPort(const string & portLabel, bool observable);
          FormulaFactory & factory() { return *_factory; }
          void generateFactory();
        
        
          void insertVariable(Variable & variable); 
          Event & createSpontaneousEvent(const string & label);
          Event & createInputEvent(const string & portLabel, const string & label);
          Event & createOutputEvent(const string & portLabel, const string & label);
          void insertInvariant(const string & label, const Formula & f);
          void insertInvariant(const Formula & f);
          void generateGlobalInvariant();
          Rule &  createRule();
          const Formula & globalInvariant() const { return _globalInvariant[0]; }
          const Formula & stateInvariant();
        

          const VariableVector & variables() const { return _variables; }
          // modifiers
          const Event & spontaneousEvent(const string & msg) const;
          bool containsSpontaneousEventOfLabel(const string & label) const
          {     return containsInputEventOfLabel("SpontaneousPort" , label);
          }
         
          const Event & inputEvent(const string & portLabel, const string & msg) const
          {
                require(ComponentTypeInvalid, containsInputEventOfLabel(portLabel,msg),
                                "inputEvent: the input event is not present");
                return *_inputEvents[_mapInEvt.find(portLabel+"."+msg)->second];
          }
        
                
          bool containsInputEventOfLabel(const string & portLabel, const string & msg) const
          {     return _mapInEvt.find(portLabel + "." + msg) != _mapInEvt.end(); }

          EventIterator beginOfInputEvents() const { return _inputEvents.begin(); }
          EventIterator endOfInputEvents() const { return _inputEvents.end(); }
        
          const Event & outputEvent(const string & portLabel, const string & msg) const
          {
                require(ComponentTypeInvalid, containsOutputEventOfLabel(portLabel,msg),
                                "outputEvent: the output event is not present");
                return *_outputEvents[_mapOutEvt.find(portLabel+"."+msg)->second];
          }
          bool containsOutputEventOfLabel(const string & portLabel, const string & msg) const
          {     return _mapOutEvt.find(portLabel + "." + msg) != _mapOutEvt.end(); }
        
          EventIterator beginOfOutputEvents() const { return _outputEvents.begin(); }
          EventIterator endOfOutputEvents() const { return _outputEvents.end(); }
        
        
          const Port & inputPort(const string & portLabel) const
          { 
                require(ComponentTypeInvalid, containsInputPortOfLabel(portLabel), "inputPort, no such a port is present");
                return *_inports[_mapInport.find(portLabel)->second];
          }
                
          bool containsInputPortOfLabel(const string & portLabel) const
          {  return _mapInport.find(portLabel) != _mapInport.end(); }
                
          PortIterator beginOfInputPorts() const { return _inports.begin(); }
          PortIterator endOfInputPorts() const { return _inports.end(); }
        
          const Port & outputPort(const string & portLabel) const
          {
                require(ComponentTypeInvalid, containsOutputPortOfLabel(portLabel), "outputPort, no such a port is present");
                return *_outports[_mapOutport.find(portLabel)->second];
          }
          bool containsOutputPortOfLabel(const string & portLabel) const
          { return _mapOutport.find(portLabel) != _mapOutport.end(); }
        
        
          PortIterator beginOfOutputPorts() const { return _outports.begin(); }
          PortIterator endOfOutputPorts() const { return _outports.end(); }
        
        
        
          bool containsVariableOfLabel(const string & label) const 
          { return _mapVar.find(label) != _mapVar.end(); }
        
          Variable  variable(const string & label) const
          { 
                require(ComponentTypeInvalid, containsVariableOfLabel(label), "variable, no such a variable is present");
                return _variables[_mapVar.find(label)->second];
          }
        
        
        
          VariableIterator beginOfVariables() const { return _variables.begin(); }
          VariableIterator endOfVariables()  const  { return _variables.end(); }

          InvariantIterator beginOfInvariant() const { return _invariant.begin(); }
          InvariantIterator endOfInvariant() const { return _invariant.end(); }
        
          RuleIterator beginOfRules() const { return _rules.begin(); }
          RuleIterator endOfRules() const { return _rules.end(); }
  
          const Port & spontaneousPort() const { return inputPort("SpontaneousPort"); }
  
          friend ostream & operator << (ostream & os, const ComponentType & component);
        };

  };
};

#endif /*COMPONENTTYPE_H_*/