DdSyncDescriptor.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__DDSYNCDESCRIPTOR__HH__
#define __DIADES__AUTOMATA__EXPERIMENTAL__DDSYNCDESCRIPTOR__HH__

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

namespace Diades
{
   namespace Automata
   {
      namespace Experimental
      {

         class DdSyncDescriptor
         {
         public:

            class Synchronisation
            {
            private:
               using SynchroDictionary = std::map<std::string, DdAutEventId>;
               SynchroDictionary _synchronisation;
               using ConstIterator = SynchroDictionary::const_iterator;
               using Iterator = SynchroDictionary::iterator;

            public:
               Synchronisation() = default;


               Synchronisation(Synchronisation const& other) = default;
               Synchronisation& operator=(Synchronisation const& other) = default;
               Synchronisation(Synchronisation&& other) = default;
               Synchronisation& operator=(Synchronisation&& other) = default;
               ~Synchronisation() = default;


               std::pair<Iterator, bool> insertSynchronisation(const std::string & compName, DdAutEventId evt);


               void eraseComponent(const std::string & compName);

               DdAutEventId getEvent(const std::string & compName) const;


               bool containsComponent(const std::string & compName) const;


               ConstIterator begin() const;

               ConstIterator end() const;


               Iterator begin();

               Iterator end();


               void clear();

               size_t
               numberOfSynchronisations() const
               {
                  return _synchronisation.size();
               }

            };
         private:
            using SynchronisationList = std::list<Synchronisation>;
            SynchronisationList _syncList;
            using ConstIterator = SynchronisationList::const_iterator;
            using Iterator = SynchronisationList::iterator;

         public:
            DdSyncDescriptor() = default;


            DdSyncDescriptor(DdSyncDescriptor const& other) = default;
            DdSyncDescriptor& operator=(DdSyncDescriptor const& other) = default;
            DdSyncDescriptor(DdSyncDescriptor&& other) = default;
            DdSyncDescriptor& operator=(DdSyncDescriptor&& other) = default;

            ~DdSyncDescriptor() = default;


            ConstIterator begin() const;

            ConstIterator end() const;


            Iterator begin();

            Iterator end();

            void clear();

            Iterator insertSynchronisation(Synchronisation && synchronisation);


            virtual bool readStream(std::istream& stream, std::string& error);



            virtual bool
            toStream(std::ostream& stream);

            SynchronisationList::size_type
            numberOfSynchronisations() const
            {
               return _syncList.size();
            }

            ostream &
            toDot(ostream & os) const;

         private:

            enum class ParsingState
            {
               LeftP, RightP, Name, QuoteName, Comma, Evt, Out, Error, End
            };

            using Size = std::string::size_type;
            using QuoteIndexes = std::pair<Size, Size>;
            using QuoteIndexesVector = std::vector< QuoteIndexes >;
            static constexpr Size NPOS = std::string::npos;


            bool analyseSynchronisationLine(const std::string & syncLine, std::string& error);



            bool
            analyseQuoteLabels(const std::string & syncLine,
                               Size currentIndex,
                               QuoteIndexesVector & quoteIndexes,
                               std::string& error);


            ParsingState analyseOut(const std::string & syncLine,
                                    Size & currentIndex, std::string & error);




            ParsingState
            analyseLeftP(const std::string& syncLine,
                         const QuoteIndexesVector& quoteIndexes,
                         size_t currentQuoteIndex,
                         Size& currentIndex,
                         std::string& error);

            ParsingState analyseName(const std::string & syncLine,
                                     Size & currentIndex,
                                     std::string & label,
                                     std::string & error);


            ParsingState analyseQuoteName(const std::string & syncLine,
                                          const QuoteIndexesVector & quoteIndexes,
                                          size_t & currentQuoteIndex,
                                          Size & currentIndex,
                                          std::string & label,
                                          std::string & error);

            ParsingState analyseComma(const std::string & syncLine,
                                      Size & currentIndex,
                                      std::string & error);

            ParsingState analyseEvt(const std::string & syncLine, Size & currentIndex, DdAutEventId & evt,
                                    std::string & error);

            ParsingState analyseRightP(const std::string & syncLine, Size & currentIndex,
                                       std::string & error);

         };

         template<typename DdAutFsmType>
         bool
         rulesToDescriptor(const SynchronisationRules<DdAutFsmType> & rules,
                           DdSyncDescriptor & desc)
         {
            bool success = rules.beginOfSynchronisedEvents() != rules.endOfSynchronisedEvents();
            std::for_each(rules.beginOfSynchronisedEvents(), rules.endOfSynchronisedEvents(),
                          [&](const SynchronisationEvent<DdAutFsmType> & syncEvent)
                          {
                             DdSyncDescriptor::Synchronisation sync;
                             auto it = syncEvent.beginOfSupport();
                             while(it != syncEvent.endOfSupport())
                             {
                          sync.insertSynchronisation(it->name(), syncEvent.getAssociatedEvent(it));
                          ++it;
                             }
                             desc.insertSynchronisation(std::move(sync));
                          });
            return success;
         }

         template<typename DdAutFsmType>
         bool
         descriptorToRules(const DdSyncDescriptor & desc,
                           ParametrizedSynchronisation<DdAutFsmType> & rules, std::string & errorMsg)
         {
            using Sync = ParametrizedSynchronisation<DdAutFsmType>;
            bool success = true;
            rules.clearRules();
            std::for_each(desc.begin(), desc.end(),
                          [&](const DdSyncDescriptor::Synchronisation & sync)
                          {
                             std::map<typename Ptr<typename Sync::Component>::ConstP, DdAutEventId> events;
                             std::for_each(sync.begin(), sync.end(),
                                           [&](const std::pair<std::string, DdAutEventId> & entry)
                                           {
                                              if(success)
                                              {
                                                 typename Sync::ComponentIterator compIt = rules.findComponent(entry.first);
                                                 success = compIt != rules.endOfComponents();
                                                 if(success)
                                                 {
                                                    success = compIt->containsEvent(entry.second);
                                                    if(success)
                                                    {
                                                       events[Ptr<typename Sync::Component>::get(*compIt)] = entry.second;
                                                    }
                                                    else
                                                    {
                                                       errorMsg += "descriptorToRules: the component " + entry.first
                                                               + " has no event with the id " + std::to_string(entry.second)+ +"Check that the rules are properly initialised with "
                                                               + "\n Please check that  the rules are properly initialised with\n"
                                                               + "the correct set of components before reading this "
                                                               + "\n synchronisation rules'descriptor.\n";
                                                    }

                                                 }
                                                 else
                                                 {
                                                    errorMsg += "descriptorToRules: the component " + entry.first
                                                            + " is unknown.\n "
                                                            + "Check that the rules are properly initialised with "
                                                            + "\n the correct set of components before reading this "
                                                            + "\n synchronisation rules'descriptor.\n";

                                                 }
                                              }

                                           });
                             if(success)
                             {
                          rules.synchronise(events.begin(), events.end());
                             }

                          });
            if(success)
            {
               rules.close();
            }
            else
            {
               rules.clear();
               errorMsg += "descriptorToRules: error so the rules are cleared.\n";
            }
            return success;
         }
      }
   }
}



#endif /* DDSYNCDESCRIPTOR_HH */