ComposableModel.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__COMPOSABLE_MODEL
#define __DIADES__AUTOMATA__COMPOSABLE_MODEL

#include <unordered_set>
#include <sstream>
#include <diades/utils/Exceptions.hh>
#include <diades/graph/GraphInt.hh>
#include <diades/graph/Graph.hh>
#include <diades/graph/ConstNodeMap.hh>
#include <diades/automata/Event.hh>
#include <diades/automata/SynchronisationRules.hh>
#include <diades/automata/StateTable.hh>

namespace Diades
{
  namespace Automata
  {
  
  

    class ComposableModel
    {
    public:
      static string typeName() { return "Diades::Automata::ComposableModel"; }
      typedef Diades::Utils::Exception<ComposableModel> Exception;

      typedef Component::OutputEventTransitionIterator OutputEventTransitionIterator;
      typedef Component::InputEventTransitionIterator InputEventTransitionIterator;
      typedef Component::OutputTransitionIterator OutputTransitionIterator;
      typedef Component::InputTransitionIterator InputTransitionIterator;
      typedef unordered_set<Event>::const_iterator EventIterator;
      typedef Diades::Graph::NodeIterator StateIterator;
      typedef unordered_set<State>::const_iterator InitialStateIterator;
      typedef const ComposableModel * ConstPointer;
      typedef ComposableModel * Pointer;

        
    private:
      typedef vector<const ComposableModel *>::size_type SizeType;
      typedef unordered_map<Event, vector<SizeType> > SupportMap;
      const unsigned _synchronisationLimit;  
      const SynchronisationRules * const _sync;   
      mutable unordered_set<Event> _usedEvents;      
      mutable unordered_set<State> _initialStates;   
      mutable vector<Event> _componentEventOf;       
      mutable SupportMap _support;
      mutable ConstNodeMap< vector<State> > _vectorStateOf;
      const vector<ConstPointer> _models;
      mutable StateTable  _stateOfVector;
      mutable State _pendingGlobalState;
      vector<const Component *> _components;
      mutable ConstNodeMap< set<Event> > _visited;
      bool _onTheFly;
    private:
        
      bool computeSupport();
        

      bool computeInitialStates(list<State> & pendingStates);
        
        
    protected:
      stringstream _log;   
      const Component * _comp;   
      bool _embeddedResult; 
      Component * _result; 
        
      bool synchronise();


      void synchronise(State state, Event event) const;


      void synchronise(State state) const;

    public:

      ConstPointer getPointer() const { return this; }
      Pointer getPointer() { return this; }
        


      ComposableModel(const Component & component,
                      const SynchronisationRules & synchronisation);


      bool valid() const { return (_sync != 0) && ((_comp != 0 && _comp->isValid()) || (_result != 0 && _result->isValid())) && (!_initialStates.empty()) && (!_usedEvents.empty()); }

      ComposableModel(const vector<ConstPointer> & models, const SynchronisationRules & synchronisation,
                      bool onTheFly);

      ComposableModel(const vector<ConstPointer> & models, const SynchronisationRules & synchronisation,
                      bool onTheFly,
                      Component * result);



      ~ComposableModel();


      
      const string & name() const { return component().name(); }

        
      const SynchronisationRules & synchronisationLaw() const
      { return *_sync;  }


      EventIterator beginOfEvents() const
      {
        return _usedEvents.begin();
      }


      EventIterator endOfEvents() const
      {
        return _usedEvents.end();
      }


      unsigned numberOfInitialStates() const
      {
        return _initialStates.size();
      }
        
      unsigned numberOfStates() const
      {
        return component().numberOfStates();
      }
         
      unsigned numberOfTransitions() const
      {
        return component().numberOfTransitions();
      }
        

      StateIterator stateBegin() const
      {
        return component().stateBegin();
      }


      StateIterator stateEnd() const
      {
        return component().stateEnd();
      }



      InitialStateIterator beginOfInitialStates() const
      {
        return _initialStates.begin();
      }


      InitialStateIterator endOfInitialStates() const
      {
        return _initialStates.end();
      }


      const Component & component() const
      {
        if(_result != nullptr)
          {
            return *_result;
          }
        return *_comp;
      }

      const vector<ConstPointer> & models() const { return _models; }

          
      const vector<State> & vectorStateOf(State s) const {
        if(_components.size() == 1)
          {
            if(_vectorStateOf[s].empty())
              {
                _vectorStateOf[s].push_back(s);
              }
          }
        return _vectorStateOf[s];
      }


      OutputTransitionIterator outputTransitionBegin(State s) const
      {
        require(Exception, s.valid(), "outputTransitionBegin: invalid state");
        require(Exception, &s.owner() == &component().behaviour(), "outputTransitionBegin: invalid state");
        if(_onTheFly && (_visited[s].empty()))
          {

            synchronise(s);

          }
        return component().outputTransitionBegin(s);
      }
      
      OutputTransitionIterator outputTransitionEnd(State s) const
      {
        require(Exception, s.valid(), "outputTransitionEnd: invalid state");
        require(Exception, &s.owner() == &component().behaviour(), "outputTransitionEnd: invalid state");
        if(_onTheFly && (_visited[s].empty()))
          {
            synchronise(s);
          }
        return component().outputTransitionEnd(s);
      }

      OutputEventTransitionIterator outputEventTransitionBegin(State s, const Event & e) const
      {
        require(Exception, s.valid(), "outputEventTransitionBegin: invalid state");
        require(Exception, &s.owner() == &component().behaviour(), "outputEventTransitionBegin: invalid state");
        require(Exception, e.isValid(), "outputEventTransitionBegin: invalid event");
        if(_onTheFly && (_visited[s].find(e) == _visited[s].end()))
          {
            synchronise(s,e);
          }
        cout << " event is " << e << " and _componentEventOf = " << _componentEventOf[e.id()] << endl;
        return component().outputEventTransitionBegin(s,_componentEventOf[e.id()]);
      }
      
      OutputEventTransitionIterator outputEventTransitionEnd(State s, const Event & e) const
      {
        require(Exception, s.valid(), "outputEventTransitionEnd: invalid state");
        require(Exception, &s.owner() == &component().behaviour(), "outputEventTransitionEnd: invalid state");
        require(Exception, e.isValid(), "outputEventTransitionEnd: invalid event");
        if(_onTheFly && (_visited[s].find(e) == _visited[s].end()))
          {
            synchronise(s,e);
          }
        return component().outputEventTransitionEnd(s,_componentEventOf[e.id()]);
      }


      InputEventTransitionIterator inputEventTransitionBegin(State s, const Event & e) const
      {
        require(Exception, s.valid(), "inputEventTransitionBegin: invalid state");
        require(Exception, &s.owner() == &component().behaviour(), "inputEventTransitionBegin: invalid state");
        require(Exception, e.isValid(), "inputEventTransitionBegin: invalid event");
        return component().inputEventTransitionBegin(s,_componentEventOf[e.id()]);
      }

        
        
      InputEventTransitionIterator inputEventTransitionEnd(State s, const Event & e) const
      {
        require(Exception, s.valid(), "inputEventTransitionEnd: invalid state");
        require(Exception, &s.owner() == &component().behaviour(), "inputEventTransitionEnd: invalid state");
        require(Exception, e.isValid(), "inputEventTransitionEnd: invalid event");
        return component().inputEventTransitionEnd(s,_componentEventOf[e.id()]);
      }




      string log() const {
        return _log.str();
      }


    };

  };
};      
  
  
#endif