SynchronisationRules.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__SYNCHRONISATIONRULES_HH
#define __DIADES__AUTOMATA__EXPERIMENTAL__SYNCHRONISATIONRULES_HH

#include<list>
#include<numeric>
#include<diades/utils/Pointer.hh>
#include<diades/utils/Exceptions.hh>
#include<diades/automata/experimental/StateMachine.hh>
#include<diades/automata/experimental/SynchronisationEvent.hh>

namespace Diades
{
   namespace Automata
   {
      namespace Experimental
      {

         template<typename StateMachine>
         class SynchronisationRules 
         {
            public:

            static string
            typeName()
            {
               return "Automata::Experimental::SynchronisationRules";
            }
            using Exception = Diades::Utils::Exception<SynchronisationRules>;
            using Component = StateMachine;
            using SyncEvent = SynchronisationEvent<Component>;
            using Event = typename SyncEvent::Event;
            using ComponentVector = typename SyncEvent::ComponentVector;
            using ComponentIterator = typename SyncEvent::ComponentIterator;
            using Size = typename SyncEvent::Size;
            using SynchronisationList = std::list<SyncEvent>;
            using SynchronisationIterator = typename SynchronisationList::iterator;
            using ConstSynchronisationIterator = typename SynchronisationList::const_iterator;

            protected:
            ComponentVector _components;
            std::list<SyncEvent> _synchros;

            public:

            SynchronisationRules() = default;


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

            SynchronisationRules(const ComponentVector & components) : _components(), _synchros()
            {
               setComponentVector(components);
            }

            bool
            setComponentVector(const ComponentVector & components)
            {
               using CompPtr = const Component *;
               using CompId = typename Component::Id;
               _components.clear();
               _synchros.clear();
               std::map<CompId, CompPtr> dictionary;
               std::for_each(components.begin(), components.end(),
                             [&](CompPtr pComp)
                             {
                                if(pComp != nullptr)
                                {
                                   dictionary[pComp->id()] = pComp;
                                }
                             }
                             );
               bool ok = (dictionary.size() == components.size());
               if(ok)
               {
                  _components.reserve(components.size());
                  std::for_each(dictionary.begin(), dictionary.end(),
                                [&](const std::pair<CompId, CompPtr> & p)
                                {
                                   _components.push_back(p.second);
                                });
               }
               else
               {
                  clear();
               }
               return ok;
            }

            virtual void
            clear()
            {
               clearRules();
               _components.clear();

            }

            virtual void
            clearRules()
            {
               _synchros.clear();
            }

            ConstSynchronisationIterator
            beginOfSynchronisedEvents() const
            {
               return _synchros.begin();
            }

            ConstSynchronisationIterator
            endOfSynchronisedEvents() const
            {
               return _synchros.end();
            }

            SynchronisationIterator
            beginOfSynchronisedEvents()
            {
               return _synchros.begin();
            }

            SynchronisationIterator
            endOfSynchronisedEvents()
            {
               return _synchros.end();
            }

            Size
            numberOfSynchronisedEvents() const
            {
               return _synchros.size();
            }

            Size
            numberOfComponents() const
            {
               return _components.size();
            }

            Size
            size() const
            {
               return _synchros.size();
            }

            ComponentIterator
            beginOfComponents() const
            {
               return ComponentIterator(&_components, nullptr, 0);
            }

            ComponentIterator
            endOfComponents() const
            {
               return ComponentIterator(&_components, nullptr, _components.size());
            }

            const Component &
                    getComponent(Size index) const
            {
               require(Exception, index < numberOfComponents(),
                       Diades::Utils::Msg("getComponent: out-of-range index '%1% > %2%'")
                       % index % numberOfComponents());
               return *_components[index];
            }

            ComponentIterator
            findComponent(const string & name) const
            {
               return std::find_if(beginOfComponents(), endOfComponents(),
                                   [&](const Component & comp) -> bool
                                   {
                                      return(name == comp.name());
                                   });
            }

            ComponentIterator
            findComponent(const Component & component) const
            {
               const Component * ptr = &component;
               return std::find_if(beginOfComponents(), endOfComponents(),
                                   [&](const Component & comp) -> bool
                                   {
                                      return(ptr == &comp);
                                   });
            }

            bool operator==(const SynchronisationRules & rules) const
            {
               return(_components == rules._components) && (_synchros == rules._synchros);
            }

            void
            getSynchronisationEvents(const Component & component, Event event,
                                     std::list< typename Ptr<SyncEvent>::ConstP > & events) const
            {
               require(Exception, component.isValid(), "getSynchronisationEvents: component is invalid");
               require(Exception, component.containsEvent(event), "getSynchronisationEvents: the event does not belong to the component");
               for(ConstSynchronisationIterator it = beginOfSynchronisedEvents();
                   it != endOfSynchronisedEvents();
                   ++it)
               {
                  ComponentIterator compIt = it->findComponent(component);
                  if(compIt != it->endOfComponents())
                  {
                     if(it->getAssociatedEvent(compIt) == event)
                     {
                        events.push_back(Ptr<SyncEvent>::get(*it));
                        ensure(Exception, Ptr<SyncEvent>::get(*it)->isValid(), "getSynchronisationEvents returns an invalid SynchronisationEvent, BUG");
                     }
                  }
               }

            }

            bool
            isValid() const
            {
               using AccValidity = Diades::Utils::AccumulateValidity<SyncEvent>;
               return !_components.empty() && std::accumulate(_synchros.begin(), _synchros.end(), true, AccValidity());

               //               if(_components.empty())
               //               {std::cout << "HELOW\n";
               //                  return false;
               //               }
               //               bool valid = true;
               //               auto it = _synchros.begin();
               //               while(valid && it != _synchros.end())
               //                  {
               //                  std::cout << "HELO\n";
               //                  valid = it->isValid();
               //                  ++it;
               //                  }
               //               return valid;

            }



         };

         template<typename SyncRules, typename SynchronisationEventEncoder>
         class SynchronisationRulesEncoder
         {
         private:
            SyncRules _rules;
         public:

            SynchronisationRulesEncoder(SyncRules & rules) : _rules(rules)
            {
               SynchronisationEventEncoder encoder(rules.numberOfSynchronisedEvents());
               std::for_each(rules.beginOfSynchronisedEvents(), rules.endOfSynchronisedEvents(),
                             [&](typename SyncRules::SyncEvent & evt)
                             {
                                evt.setSynchronisedEvent(encoder.newEvent(evt));
                             });

            }
         };


      }
   }
}

#endif /* __DIADES__AUTOMATA__EXPERIMENTAL__SYNCHRONISATIONRULES_HH */