ComposableModel.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__COMPOSABLEMODEL__HH__
#define __DIADES__AUTOMATA__EXPERIMENTAL__COMPOSABLEMODEL__HH__

#include<unordered_set>
#include<diades/utils/NAryTree.hh>
#include<diades/utils/Enumerators.hh>
#include<diades/utils/MapIterators.hh>
#include<diades/utils/Pointer.hh>
#include<diades/automata/experimental/SynchronisationRules.hh>

namespace Diades
{
   namespace Automata
   {
      namespace Experimental
      { 
         
         
         

         template<typename Fsm, typename StateCreator>
         class ComposableModel
         {
         public:

            static string
            typeName()
            {
               return "Diades::Automata::Experimental::ComposableModel";
            }
            using Exception = Diades::Utils::Exception<ComposableModel>;
            using Component = Fsm;
            using Event = typename Component::EventPropertyId;
            using OutputEventTransitionIterator = typename Component::OutputEventTransitionIterator;
            using InputEventTransitionIterator = typename Component::InputEventTransitionIterator;
            using OutputTransitionIterator = typename Component::OutputTransitionIterator;
            using InputTransitionIterator = typename Component::InputTransitionIterator;
            using InitialStateIterator = typename Component::InitialStateIterator;
            using StateIterator = typename Component::StateIterator;
            using TransitionIterator = typename Component::TransitionIterator;
            using State = typename Component::State;
            using Transition = typename Component::Transition;
            using StateVector = std::vector<State>;
            using StateOfVector = Diades::Utils::NAryTree<State, State, std::unordered_map>;
            using VectorOfState = std::unordered_map<State, StateVector>;
            using InitialStateEnumerator = Diades::Utils::RangesEnumeration<InitialStateIterator>;
            using SyncRules = SynchronisationRules<Fsm>;
            using SyncEvent = typename SyncRules::SyncEvent;
         private:
            vector<typename Ptr<ComposableModel>::ConstP> _models;
            std::unordered_map<typename Ptr<Component>::ConstP, size_t> _compIds;
            typename Ptr<Component>::ConstP _comp;
            typename Ptr<Component>::P _synchronisedFsm;
            typename Ptr<SyncRules>::ConstP _sync;
            mutable StateOfVector _stateOfVector;
            mutable VectorOfState _vectorOfState;
            mutable InitialStateEnumerator _initialStateEnumerator;
            std::unordered_map<typename Ptr<SyncEvent>::ConstP, std::unordered_set<size_t> > _synchronisationEventsInUse;
            std::unordered_map<Event, typename Ptr<SyncEvent>::ConstP > _synchronisationEventsOfSynchronisedEvent;
            mutable std::unordered_map<State, std::unordered_set < Event>> _pendingOutputs;
            mutable std::unordered_map<State, std::unordered_set < Event>> _pendingInputs;
            bool _valid;
            mutable bool _notStarted;
            mutable typename Ptr<StateCreator>::P _creator;

         private:

            void
            createInitialStates() const
            {
               StateVector initialStates;
               State initialState;
               while(newInitialState(initialStates, initialState))
               {
               }
            }

         public:

            InitialStateIterator
            initialStateBegin() const
            {
               if(_comp == nullptr)
               {
                  createInitialStates();
                  return _synchronisedFsm->initialStateBegin();
               }
               return _comp->initialStateBegin();
            }

            InitialStateIterator
            initialStateEnd() const
            {
               if(_comp == nullptr)
               {

                  StateVector initialStates;
                  initialStates.reserve(_models.size());
                  State initialState;
                  while(newInitialState(initialStates, initialState))
                  {
                  }
                  return _synchronisedFsm->initialStateEnd();
               }
               return _comp->initialStateEnd();
            }

            bool
            isValid() const
            {
               return _valid;
            }



            ComposableModel() = default;


            ComposableModel(ComposableModel const& other) = default;
            ComposableModel& operator=(ComposableModel const& other) = default;
            ComposableModel(ComposableModel && other) = default;
            ComposableModel& operator=(ComposableModel && other) = default;
            virtual ~ComposableModel() = default;

            ComposableModel(const Component & component,
                            const SynchronisationRules<Fsm> & synchronisation) :
            _models(),
            _compIds(),
            _comp(Ptr<Component>::get(component)),
            _synchronisedFsm(nullptr),
            _sync(Ptr<SynchronisationRules<Fsm>>::get(synchronisation)),
            _stateOfVector(),
            _vectorOfState(),
            _initialStateEnumerator(),
            _synchronisationEventsInUse(),
            _synchronisationEventsOfSynchronisedEvent(),
            _pendingOutputs(),
            _pendingInputs(),
            _valid(true),
            _notStarted(true),
            _creator(nullptr)
            {
            }

            ComposableModel(const vector<typename Ptr<ComposableModel>::ConstP> & models, const SynchronisationRules<Fsm> & synchronisation, StateCreator & creator) :
            _models(models),
            _compIds(),
            _comp(nullptr),
            _synchronisedFsm(nullptr),
            _sync(Ptr<SynchronisationRules<Fsm>>::get(synchronisation)),
            _stateOfVector(),
            _vectorOfState(),
            _initialStateEnumerator(),
            _synchronisationEventsInUse(),
            _synchronisationEventsOfSynchronisedEvent(),
            _pendingOutputs(),
            _pendingInputs(),
            _valid(true),
            _notStarted(true),
            _creator(Ptr<StateCreator>::get(creator))
            {
               for(size_t i = 0; i < models.size(); ++i)
               {
                  _compIds[Ptr<Component>::get(models[i]->component())] = i;
               }
               _valid = computeSynchronisationEventsInUse();
            }

            ComposableModel(const vector<typename Ptr<ComposableModel>::ConstP> & models, const SynchronisationRules<Fsm> & synchronisation,
                            StateCreator & creator,
                            Fsm & result) :
            _models(models),
            _compIds(),
            _comp(nullptr),
            _synchronisedFsm(Ptr<Fsm>::get(result)),
            _sync(Ptr<SynchronisationRules<Fsm>>::get(synchronisation)),
            _stateOfVector(),
            _vectorOfState(),
            _initialStateEnumerator(),
            _synchronisationEventsInUse(),
            _synchronisationEventsOfSynchronisedEvent(),
            _pendingOutputs(),
            _pendingInputs(),
            _valid(true),
            _notStarted(true),
            _creator(Ptr<StateCreator>::get(creator))
            {
               for(size_t i = 0; i < models.size(); ++i)
               {
                  _compIds[Ptr<Fsm>::get(models[i]->component())] = i;
               }
               _valid = computeSynchronisationEventsInUse();
               _creator->setStateMachine(result);
               initInitialStateEnumeration();
            }

            bool
            completeSynchronisation(Fsm & synchronisedFsm)
            {
               if(isValid())
               {
                  bool result = true;
                  init(synchronisedFsm);
                  completeSynchronisation();
                  return result;
               }
               return false;
            }

         private:

            void
            completeSynchronisation()
            {
               if(_comp == nullptr && _synchronisedFsm != nullptr)
               {
                  createInitialStates();
                  while(!_pendingOutputs.empty())
                  {
                     State pendingState = _pendingOutputs.begin()->first;
                     Event pendingEvent = *(_pendingOutputs.begin()->second.begin());
                     synchroniseOutputs(pendingState, pendingEvent);
                  }
               }
            }

         public:

            StateIterator
            stateBegin() const
            {
               if(_comp == nullptr)
               {
                  if(_notStarted || (!_pendingOutputs.empty()))
                  {
                     completeSynchronisation();
                  }
                  return _synchronisedFsm->stateBegin();
               }
               return _comp->stateBegin();
            }

            StateIterator
            stateEnd() const
            {
               if(_comp == nullptr)
               {
                  if(_notStarted || (!_pendingOutputs.empty()))
                  {
                     completeSynchronisation();
                  }
                  return _synchronisedFsm->stateEnd();
               }
               return _comp->stateEnd();
            }

            TransitionIterator
            transitionBegin() const
            {
               if(_comp == nullptr)
               {
                  if(_notStarted || (!_pendingOutputs.empty()))
                  {
                     completeSynchronisation();
                  }
                  return _synchronisedFsm->transitionBegin();
               }
               return _comp->transitionBegin();
            }

            TransitionIterator
            transitionEnd() const
            {
               if(_comp == nullptr)
               {
                  if(_notStarted || (!_pendingOutputs.empty()))
                  {
                     completeSynchronisation();
                  }
                  return _synchronisedFsm->transitionEnd();
               }
               return _comp->transitionEnd();
            }

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

            void
            init(Fsm & synchronisedFsm)
            {
               if(_comp == nullptr)
               {
                  _synchronisedFsm = Ptr<Fsm>::get(synchronisedFsm);
                  _synchronisedFsm->clear();
                  _stateOfVector.clear();
                  _vectorOfState.clear();
                  _pendingOutputs.clear();
                  _pendingInputs.clear();
                  _notStarted = true;
                  if(_creator != nullptr)
                  {
                     _creator->setStateMachine(synchronisedFsm);
                  }
                  initInitialStateEnumeration();
               }
            }
         private:

            void
            initInitialStateEnumeration()
            {
               std::vector<InitialStateIterator> start;
               start.reserve(models().size());
               std::vector<InitialStateIterator> end;
               end.reserve(models().size());
               std::for_each(_models.begin(), _models.end(),
                             [&](typename Ptr<ComposableModel>::ConstP composableModel)
                             {
                                start.push_back(composableModel->component().initialStateBegin());
                                end.push_back(composableModel->component().initialStateEnd());
                             });
               _initialStateEnumerator.setup(std::move(start), std::move(end));
            }
         public:

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

            const vector<typename Ptr<ComposableModel>::ConstP> &
            models() const
            {
               return _models;
            }

            vector<typename Ptr<ComposableModel>::ConstP> &
            models()
            {
               return _models;
            }

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

            bool
            newState(const StateVector & states, State & result) const
            {
               using KeyIterator = Diades::Utils::ConstUnorderedMapKeyIterator<Event, typename Ptr<SyncEvent>::ConstP>;
               if(_stateOfVector.getLeaf(states.begin(), states.end(), result))
               {
                  return false;
               }
               bool created;
               std::tie(result,created) = _creator->newState(states);
               _stateOfVector.insertSuccessiveBranches(states.begin(), states.end(), result);
               _vectorOfState[result] = states;
               _notStarted = false;
               _pendingOutputs[result].insert(
                                              KeyIterator(_synchronisationEventsOfSynchronisedEvent.begin()),
                                              KeyIterator(_synchronisationEventsOfSynchronisedEvent.end()));
               _pendingInputs[result].insert(
                                             KeyIterator(_synchronisationEventsOfSynchronisedEvent.begin()),
                                             KeyIterator(_synchronisationEventsOfSynchronisedEvent.end()));
               return created;
            }

            bool
            newInitialState(StateVector & initialStates, State & initialState) const
            {
               if(_initialStateEnumerator.completed())
               {
                  return false;
               }
               bool isCreated = false;
               initialStates.clear();
               initialStates.reserve(_models.size());
               while(!isCreated && !_initialStateEnumerator.completed())
               {
                  std::for_each(_initialStateEnumerator.current().begin(),
                                _initialStateEnumerator.current().end(),
                                [&](typename InitialStateEnumerator::Value it)
                                {
                                   initialStates.push_back(*it);
                                }
                                );
                  isCreated = newState(initialStates, initialState);
                  if(!isCreated)
                  {
                     _initialStateEnumerator.hasNext();
                     initialStates.clear();
                  }
                  else
                  {
                     _synchronisedFsm->setInitial(initialState);
                  }
               }
               return isCreated;
            }

            void
            synchroniseOutputs(State state, Event event) const
            {
               auto evtIt = _synchronisationEventsOfSynchronisedEvent.find(event);
               if(evtIt != _synchronisationEventsOfSynchronisedEvent.end())
               {
                  const auto & synchronisationEvent = *(evtIt->second);
                  auto stateIt = _vectorOfState.find(state);
                  if(stateIt != _vectorOfState.end())
                  {
                     const auto & stateVector = stateIt->second;
                     StateVector targetVector = stateVector;
                     auto supportIt = _synchronisationEventsInUse.find(Ptr<SyncEvent>::get(synchronisationEvent));
                     if(supportIt != _synchronisationEventsInUse.end())
                     {
                        const auto & support = supportIt->second;
                        std::vector<OutputEventTransitionIterator> start, end;
                        start.reserve(support.size());
                        end.reserve(support.size());
                        std::for_each(support.begin(), support.end(),
                                      [&](size_t modelIndex)
                                      {
                                         auto & model = _models[modelIndex];
                                         auto & compState = stateVector[modelIndex];
                                         auto event = synchronisationEvent.getAssociatedEvent(model->component());
                                         start.push_back(model->outputEventTransitionBegin(compState, event));
                                         end.push_back(model->outputEventTransitionEnd(compState, event));
                                      });

                        Diades::Utils::RangesEnumeration<OutputEventTransitionIterator> enumerator(start, end);
                        if(!enumerator.empty())
                        {
                           enumerator.start();
                           do
                           {
                              size_t index = 0;
                              for(auto it = support.begin(); it != support.end(); ++it)
                              {
                                 targetVector[*it] = (enumerator.current().at(index))->target();
                                 ++index;
                              }
                              State target;
                              newState(targetVector, target);
                              _synchronisedFsm->newTransition(state, target, event);
                           }
                           while(enumerator.hasNext());
                        }

                     }
                  }
                  _pendingOutputs[state].erase(event);
                  if(_pendingOutputs[state].empty())
                  {
                     _pendingOutputs.erase(state);
                  }
               }
            }

            void
            synchroniseInputs(State state, Event event) const
            {
               auto evtIt = _synchronisationEventsOfSynchronisedEvent.find(event);
               if(evtIt != _synchronisationEventsOfSynchronisedEvent.end())
               {
                  const auto & synchronisationEvent = *(evtIt->second);
                  auto stateIt = _vectorOfState.find(state);
                  if(stateIt != _vectorOfState.end())
                  {
                     const auto & stateVector = stateIt->second;
                     StateVector sourceVector = stateVector;
                     auto supportIt = _synchronisationEventsInUse.find(Ptr<SyncEvent>::get(synchronisationEvent));
                     if(supportIt != _synchronisationEventsInUse.end())
                     {
                        const auto & support = supportIt->second;
                        std::vector<InputEventTransitionIterator> start, end;
                        start.reserve(support.size());
                        end.reserve(support.size());
                        std::for_each(support.begin(), support.end(),
                                      [&](size_t modelIndex)
                                      {
                                         auto & model = _models[modelIndex];
                                         auto & compState = stateVector[modelIndex];
                                         auto event = synchronisationEvent.getAssociatedEvent(model->component());
                                         start.push_back(model->inputEventTransitionBegin(compState, event));
                                         end.push_back(model->inputEventTransitionEnd(compState, event));
                                      });

                        Diades::Utils::RangesEnumeration<InputEventTransitionIterator> enumerator(start, end);
                        if(!enumerator.empty())
                        {
                           enumerator.start();

                           do
                           {
                              size_t index = 0;
                              for(auto it = support.begin(); it != support.end(); ++it)
                              {
                                 sourceVector[*it] = (enumerator.current().at(index))->target();
                                 ++index;
                              }
                              State source;
                              newState(sourceVector, source);
                              _synchronisedFsm->newTransition(source, state, event);
                           }
                           while(enumerator.hasNext());
                        }

                     }
                  }
                  _pendingInputs[state].erase(event);
                  if(_pendingInputs[state].empty())
                  {
                     _pendingInputs.erase(state);
                  }
               }
            }

            OutputEventTransitionIterator
            outputEventTransitionBegin(State s, Event e) const
            {
               if(_comp == nullptr)
               {
                  auto it = _pendingOutputs.find(s);

                  if((it != _pendingOutputs.end())
                     &&
                     (it->second.find(e) != it->second.end()))
                  {
                     synchroniseOutputs(s, e);
                  }
                  return _synchronisedFsm->outputEventTransitionBegin(s, e);
               }
               return _comp->outputEventTransitionBegin(s, e);
            }

            OutputEventTransitionIterator
            outputEventTransitionEnd(State s, Event e) const
            {
               if(_comp == nullptr)
               {
                  auto it = _pendingOutputs.find(s);

                  if((it != _pendingOutputs.end())
                     &&
                     (it->second.find(e) != it->second.end()))
                  {
                     synchroniseOutputs(s, e);
                  }
                  return _synchronisedFsm->outputEventTransitionEnd(s, e);
               }
               return _comp->outputEventTransitionEnd(s, e);
            }

            InputEventTransitionIterator
            inputEventTransitionBegin(State s, Event e) const
            {
               if(_comp == nullptr)
               {

                  auto it = _pendingInputs.find(s);

                  if((it != _pendingInputs.end())
                     &&
                     (it->second.find(e) != it->second.end()))
                  {
                     synchroniseInputs(s, e);
                  }
                  return _synchronisedFsm->inputEventTransitionBegin(s, e);
               }
               return _comp->inputEventTransitionBegin(s, e);
            }

            InputEventTransitionIterator
            inputEventTransitionEnd(State s, Event e) const
            {
               if(_comp == nullptr)
               {
                  auto it = _pendingInputs.find(s);

                  if((it != _pendingInputs.end())
                     &&
                     (it->second.find(e) != it->second.end()))
                  {
                     synchroniseInputs(s, e);
                  }
                  return _synchronisedFsm->inputEventTransitionEnd(s, e);
               }
               return _comp->inputEventTransitionEnd(s, e);
            }

            OutputTransitionIterator
            outputTransitionBegin(State s) const
            {
               if(_comp == nullptr)
               {
                  auto it = _pendingOutputs.find(s);
                  if(it != _pendingOutputs.end())
                  {
                     auto currentSize = _pendingOutputs.size();
                     while(_pendingOutputs.size() == currentSize)
                     {

                        Event pendingEvent = *(it->second.begin());
                        synchroniseOutputs(s, pendingEvent);
                     }
                  }
                  return _synchronisedFsm->outputTransitionBegin(s);
               }
               return _comp->outputTransitionBegin(s);
            }

            OutputTransitionIterator
            outputTransitionEnd(State s) const
            {
               if(_comp == nullptr)
               {
                  auto it = _pendingOutputs.find(s);
                  if(it != _pendingOutputs.end())
                  {
                     auto currentSize = _pendingOutputs.size();
                     while(_pendingOutputs.size() == currentSize)
                     {

                        Event pendingEvent = *(it->second.begin());
                        synchroniseOutputs(s, pendingEvent);
                     }
                  }

                  return _synchronisedFsm->outputTransitionEnd(s);
               }
               return _comp->outputTransitionEnd(s);
            }

            InputTransitionIterator
            inputTransitionBegin(State s) const
            {
               if(_comp == nullptr)
               {
                  auto it = _pendingInputs.find(s);
                  if(it != _pendingInputs.end())
                  {
                     auto currentSize = _pendingInputs.size();
                     while(_pendingInputs.size() == currentSize)
                     {

                        Event pendingEvent = *(it->second.begin());
                        synchroniseInputs(s, pendingEvent);
                     }
                  }
                  return _synchronisedFsm->inputTransitionBegin(s);
               }
               return _comp->inputTransitionBegin(s);
            }

            InputTransitionIterator
            inputTransitionEnd(State s) const
            {
               if(_comp == nullptr)
               {
                  auto it = _pendingInputs.find(s);
                  if(it != _pendingInputs.end())
                  {
                     auto currentSize = _pendingInputs.size();
                     while(_pendingInputs.size() == currentSize)
                     {

                        Event pendingEvent = *(it->second.begin());
                        synchroniseInputs(s, pendingEvent);
                     }
                  }
                  return _synchronisedFsm->inputTransitionEnd(s);
               }
               return _comp->inputTransitionEnd(s);
            }






         private:

            bool
            computeSynchronisationEventsInUse()
            {
               auto it = _sync->beginOfSynchronisedEvents();
               while(it != _sync->endOfSynchronisedEvents())
               {
                  if(!checkSynchronisationEvent(*it))
                  {
                     _synchronisationEventsInUse.clear();
                     return false;
                  }
                  ++it;
               }
               return true;
            }

            bool
            checkSynchronisationEvent(const SyncEvent & syncEvent)
            {
               bool isIn = false;
               bool isOut = false;
               auto it = syncEvent.beginOfSupport();
               while(!(isIn && isOut) && it != syncEvent.endOfSupport())
               {
                  auto compIdIt = _compIds.find(Ptr<Component>::get(*it));
                  bool found = (compIdIt != _compIds.end());
                  isIn = isIn || found;
                  isOut = isOut || (!found);
                  if(found)
                  {
                     _synchronisationEventsOfSynchronisedEvent[syncEvent.synchronisedEvent()] = Ptr<SyncEvent>::get(syncEvent);
                     _synchronisationEventsInUse[Ptr<SyncEvent>::get(syncEvent)].insert(compIdIt->second);
                  }
                  ++it;
               }
               return !(isIn && isOut);
            }



         };
      }
   }
}


#endif /* __DIADES__AUTOMATA__EXPERIMENTAL__COMPOSABLEMODEL__HH__ */