DdAutFile.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__DDAUTFILE__HH
#define __DIADES__AUTOMATA__EXPERIMENTAL__DDAUTFILE__HH

#include<diades/utils/StringTools.hh>
#include<diades/automata/experimental/SynchronisationRules.hh>
#include "AutFile.hh"
#include "StatePropertyManager.hh"
#include "Event.hh"
#include "Printer.hh"
#include "FiniteAutomaton.hh"
#include "SynchronisationEvent.hh"

namespace Diades
{
   namespace Automata
   {

      namespace Experimental
      {

         using DdAutStateId = AutStateId;

         using DdAutEventId = size_t;

         using DdAutFsm = StateMachine<DdAutStateId, DdAutEventId>;

         using DdAutFA = FiniteAutomaton<DdAutStateId, DdAutEventId>;


         using DdAutStateLabel = StatePropertyAsStringLabel;

         using DdAutEventLabel = std::string;

         using DdAutStateManager = StatePropertyManager<DdAutStateLabel, DdAutStateId>;

         using DdAutEventManager = EventManager<DdAutEventLabel, DdAutEventId>;

        struct ManagedDdAutFsm
        {
          DdAutFsm & fsm;
          DdAutStateManager & sMgr;
          DdAutEventManager & eMgr;
          ManagedDdAutFsm(DdAutFsm & ddAutFsm,
                          DdAutStateManager & stateManager,
                          DdAutEventManager & eventManager):fsm(ddAutFsm),
                                                            sMgr(stateManager),
                                                            eMgr(eventManager){}
          ManagedDdAutFsm(ManagedDdAutFsm && mFsm):fsm(mFsm.fsm),sMgr(mFsm.sMgr),eMgr(mFsm.eMgr){}
        };
        
        struct ConstManagedDdAutFsm
        {
          const DdAutFsm & fsm;
          const DdAutStateManager & sMgr;
          const DdAutEventManager & eMgr;
          ConstManagedDdAutFsm(const DdAutFsm & ddAutFsm,
                               const DdAutStateManager & stateManager,
                               const DdAutEventManager & eventManager):fsm(ddAutFsm),
                                                                       sMgr(stateManager),
                                                                       eMgr(eventManager){}
          ConstManagedDdAutFsm(ConstManagedDdAutFsm && mFsm):fsm(mFsm.fsm),sMgr(mFsm.sMgr),eMgr(mFsm.eMgr){}
        };


        struct ManagedDdAutFA
        {
          DdAutFA & fa;
          DdAutStateManager & sMgr;
          DdAutEventManager & eMgr;
          ManagedDdAutFA(DdAutFA & ddAutFa,
                         DdAutStateManager & stateManager,
                          DdAutEventManager & eventManager):fa(ddAutFa),
                                                            sMgr(stateManager),
                                                            eMgr(eventManager){}
          ManagedDdAutFA(ManagedDdAutFA && mFa):fa(mFa.fa),sMgr(mFa.sMgr),eMgr(mFa.eMgr){}
        };


        struct ConstManagedDdAutFA
        {
          const DdAutFA & fa;
          const DdAutStateManager & sMgr;
          const DdAutEventManager & eMgr;
          ConstManagedDdAutFA(const DdAutFA & ddAutFA,
                              const DdAutStateManager & stateManager,
                               const DdAutEventManager & eventManager):fa(ddAutFA),
                                                                       sMgr(stateManager),
                                                                       eMgr(eventManager){}
          ConstManagedDdAutFA(ConstManagedDdAutFA && mFa):fa(mFa.fa),sMgr(mFa.sMgr),eMgr(mFa.eMgr){}
        };
        
        using DdAutStatePrinter = StateInfoManagerPrettyPrinter<DdAutStateLabel, DdAutStateId>;

        using DdAutEventPrinter = EventManagerPrettyPrinter<DdAutEventLabel, DdAutEventId>;


        using DdAutComma = Diades::Utils::StringBinaryCombination<char, ',', std::char_traits<char>, std::allocator<char>>;

        using DdAutAmpersand = Diades::Utils::StringBinaryCombination<char, '&', std::char_traits<char>, std::allocator<char>>;


        using DdAutBraces = Diades::Utils::StringDelimiter<char, '{', '}', std::char_traits<char>, std::allocator<char>>;

        using DdAutParentheses = Diades::Utils::StringDelimiter<char, '(', ')', std::char_traits<char>, std::allocator<char>>;


        using DdAutDisjunction = Diades::Utils::Disjunction<DdAutStateLabel, DdAutComma, DdAutBraces>;

        using DdAutConjunction = Diades::Utils::Conjunction<DdAutStateLabel, DdAutComma, DdAutParentheses>;

        using DdAutProjection = DiGraphComponentStartingWith<DdAutStateLabel, char, '|', DdAutComma, DdAutBraces>;


        using DdAutSynchronisation = Diades::Utils::Conjunction<DdAutEventLabel, DdAutAmpersand, Diades::Utils::NoDelimiter<char, std::char_traits<char>, std::allocator<char>>>;


         bool fsmFromDdAutFile(std::istream& stream,
                               const ManagedDdAutFsm &mFsm);



        bool faFromDdAutFile(std::istream& stream,
                             const ManagedDdAutFA & mFa);
        
        bool fsmToDdAutFile(ostream& stream,
                            const ConstManagedDdAutFsm & mFsm);



        bool faToDdAutFile(ostream& stream, const ConstManagedDdAutFA & mFa);
        

                             bool
         fsmToAutFile(ostream& stream, const DdAutFsm & fsm,
                      const DdAutEventManager & eManager,
                      bool enforce = false);





        template<typename DdAutFsmType>
        class DefaultDdAutSynchronisationEventEncoder :
          public SynchronisationEventEncoder<SynchronisationEvent<DdAutFsmType>>
         {


            public:
            using SEE = SynchronisationEventEncoder<SynchronisationEvent < DdAutFsmType >>;

            private:
            typename SEE::Event _newEvent;


            public:

            DefaultDdAutSynchronisationEventEncoder(size_t numberOfSynchronisationEventsToEncode) :
                    SEE(numberOfSynchronisationEventsToEncode), _newEvent(0)
            {
            }

            virtual typename SEE::Event newEvent(const typename SEE::SyncEvent & synchronisedEvent)
            {
               return _newEvent++;
            }
         };

         
         
         template<typename DdAutFsmType>
         bool
         generateSynchronisedDdAutEventLabels(const SynchronisationRules<DdAutFsmType> & synchro,
                                              const std::vector<DdAutEventManager> & eventManagers,
                                              DdAutEventManager & syncEventManager)
         {
            bool result = true;
            for(auto it = synchro.beginOfSynchronisedEvents();
                it != synchro.endOfSynchronisedEvents();
                ++it)
            {
               const auto & syncEvent = *it;
               size_t index = 0;
               std::vector<string> events;
               auto compIt = syncEvent.beginOfComponents();
               while(compIt != syncEvent.endOfComponents())
               {
                  auto evt = compIt.getAssociatedEvent();
                  if(evt != compIt->nullEvent())
                  {
                     events.push_back(compIt->name() + "." + eventManagers[index].getEvent(evt));
                  }
                  ++compIt;
                  ++index;
               }
               result &= syncEventManager.setEvent(DdAutSynchronisation()(events.begin(), events.end()),
                                                   syncEvent.synchronisedEvent());
            }
            return result;
         }



         void
         insertDdAutFA(const DdAutFA & sourceFsm,
                       const DdAutStateManager & sourceStateManager,
                       const DdAutEventManager & sourceEventManager,
                       DdAutFA & targetFsm,
                       DdAutStateManager & targetStateManager,
                       DdAutEventManager & targetEventManager);

         template<typename DdAutFARange, typename RangeDdAutSM, typename RangeDdAutEM>
         bool
         insertFiniteAutomata(DdAutFARange faRange,
                              RangeDdAutSM smRange,
                              RangeDdAutEM evRange,
                              DdAutFA & result,
                              DdAutStateManager & targetStateManager,
                              DdAutEventManager & targetEventManager)
         {
            auto faIt = faRange.first;
            auto smIt = smRange.first;
            auto evIt = evRange.first;
            while(faIt != faRange.second)
            {
               if(smIt == smRange.second || evIt == evRange.second)
               {
                  return false;
               }
               insertDdAutFA(*faIt, *smIt, *evIt, result, targetStateManager, targetEventManager);
               ++faIt;
               ++smIt;
               ++evIt;
               ;
            }
            return true;
         }
      }
   }
}


#endif /* __DIADES__AUTOMATA__EXPERIMENTAL__DDAUTFILE_HH */