ParametrizedSynchronisation.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__PARAMETRIZEDSYNCHRONISATION__HH__
#define __DIADES__AUTOMATA__EXPERIMENTAL__PARAMETRIZEDSYNCHRONISATION__HH__

#include<diades/automata/experimental/SynchronisationRules.hh>

namespace Diades
{
   namespace Automata
   {
      namespace Experimental
      {

         template<typename StateMachine>
         class ParametrizedSynchronisation : public SynchronisationRules<StateMachine>
         {
         public:

            static string
            typeName()
            {
               return "Automata::Experimental::ParametrizedSynchronisation";
            }
            using Exception = Diades::Utils::Exception<ParametrizedSynchronisation>;
            using SR = SynchronisationRules<StateMachine>;
            using Component = typename SR::Component;
            using SyncEvent = typename SR::SyncEvent;
            using Event = typename SR::Event;
            using ComponentVector = typename SR::ComponentVector;
            using ComponentIterator = typename SR::ComponentIterator;
            using Size = typename SR::Size;
            using SynchronisationList = typename SR::SynchronisationList;
            using SynchronisationIterator = typename SR::SynchronisationIterator;

         private:
            bool _locked;
            std::unordered_map<typename Ptr<Component>::ConstP, std::set<Event> > _isSynchronized;
            using NullEvent = typename StateMachine::NullEventPropertyId;
            const Event _nullEvent = NullEvent().nullValue();
         public:


            ParametrizedSynchronisation() = default;


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

            ParametrizedSynchronisation(const ComponentVector & components) :
            SR(components), _isSynchronized()
            {
               _locked = false;
            }

            bool
            init(const ComponentVector & components)
            {
               clear();
               return SR::setComponentVector(components);
            }

            void
            synchronise(Event e)
            {
               require(Exception, SR::isValid(), "synchronise (Parametrized): the rules are not valid");
               if(!isLocked())
               {
                  if(e != _nullEvent)
                  {

                     list<ComponentIterator> support;
                     for(ComponentIterator it = SR::beginOfComponents();
                         it != SR::endOfComponents();
                         ++it)
                     {
                        if(it->containsEvent(e))
                        {
                           support.push_back(it);
                        }
                     }
                     require(Exception, !support.empty(), "synchronise (Parametrized): the event has no support");
                     SR::_synchros.push_back(SynchronisationEvent(SR::_components));
                     std::for_each(support.begin(), support.end(),
                                   [&](ComponentIterator it)
                                   {
                                      SR::_synchros.back().addEvent(*it, e);
                                      _isSynchronized[Ptr<Component>::get(*it)].insert(e);
                                   });

                  }
               }
               ensure(Exception, SR::isValid(), "synchronise (Parametrized): the rules are not valid");
            }

            template<typename ComponentEventIterator>
            void
            synchronise(ComponentEventIterator begin, ComponentEventIterator end)
            {
               synchronise(begin, end, false);
            }

            template<typename ComponentEventIterator>
            void
            synchronise(ComponentEventIterator begin, ComponentEventIterator end, bool relaxation)
            {
               require(Exception, SR::isValid(), "synchronise (Parametrized + relaxation): the rules are not valid");
               if(!isLocked())
               {
                  SR::_synchros.push_back(SynchronisationEvent(SR::_components));
                  auto & evt = SR::_synchros.back();
                  std::for_each(begin, end,
                                [&](const std::pair<typename Ptr<Component>::ConstP, Event> & entry)
                                {
                                   evt.addEvent(*entry.first, entry.second);
                                    _isSynchronized[entry.first].insert(entry.second);
                                   if(relaxation)
                                   {
                                SR::_synchros.push_back(SynchronisationEvent(SR::_components));
                                SR::_synchros.back().addEvent(*entry.first, entry.second);
                               
                                   }
                                }
                                );
               }
               ensure(Exception, SR::isValid(), "synchronise (Parametrized + relaxation): the rules are not valid");
            }

            void
            close()
            {
               require(Exception, SR::isValid(), "close: the rules are not valid");
               if(!isLocked())
               {
                  
                  for(ComponentIterator it = SR::beginOfComponents();
                      it != SR::endOfComponents();
                      ++it)
                  {
                     for(auto eventIt = it->eventBegin();
                         eventIt != it->eventEnd();
                         ++eventIt)
                     {
                        auto & syncSet = _isSynchronized[Ptr<Component>::get(*it)];
                        if(syncSet.find(*eventIt) == syncSet.end())
                        {
                           
                           SR::_synchros.push_back(SynchronisationEvent(SR::_components));
                           SR::_synchros.back().addEvent(*it, *eventIt);
                           syncSet.insert(*eventIt);
                        }
                     }
                  }
               //   SR::encodeEvents();
                  _locked = true;
               }
               ensure(Exception, SR::isValid(), "close: the rules are not valid");
            }

            void
            open()
            {
               _locked = false;
            }

            bool
            isLocked() const
            {
               return _locked;
            }

            virtual void
            clear()
            {
               _isSynchronized.clear();
               _locked = false;
               SR::clear();
            }
            
            virtual void
            clearRules()
            {
               _isSynchronized.clear();
               _locked = false;
               SR::clearRules();
            }
         };

      }
   }
}

#endif /* __DIADES__AUTOMATA__EXPERIMENTAL__PARAMETRIZEDSYNCHRONIZATION__HH__ */