StateInserter.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__STATEINSERTER__HH__
#define __DIADES__AUTOMATA__EXPERIMENTAL__STATEINSERTER__HH__

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

namespace Diades
{
   namespace Automata
   {
      namespace Experimental
      {
         
         
         template<typename Fsm, typename _IdGenerator>
         class StateIdGenerator
         {
         public:
            using StateId = typename Fsm::StatePropertyId;
            using IdGen = _IdGenerator;
         private:

            typename Diades::Utils::Ptr<Fsm>::ConstP _target;
            typename Diades::Utils::Ptr<IdGen>::P _generator;

            bool _rename;

         public:

            StateIdGenerator(const Fsm & target, IdGen & generator, bool rename) :
            _target(Diades::Utils::Ptr<Fsm>::get(target)),
            _generator(Diades::Utils::Ptr<IdGen>::get(generator)),
            _rename(rename)
            {
            }

            StateId
            generate(StateId sourceStateId)
            {
               if(_rename || (_target->getState(sourceStateId).valid()))
               {
                  auto genStateId = _generator->another();
                  while(_target->getState(genStateId).valid())
                  {
                     genStateId = _generator->another();
                  }
                  return genStateId;
               }
               return sourceStateId;
            }

         };

         template<typename _StateIdGenerator, typename _StateCreator>
         class StateInserter
         {
         public:

            using StateIdGenerator = _StateIdGenerator;
            using StateCreator = _StateCreator;
            using Fsm = typename StateCreator::Fsm;
            using State = typename Fsm::State;
            using StateId = typename Fsm::StatePropertyId;
            using StateIdMap = std::unordered_map<StateId, StateId>;

         private:
            StateIdMap _stateOf;
            typename Diades::Utils::Ptr<StateIdGenerator>::P _generator;
            typename Diades::Utils::Ptr<StateCreator>::P _creator;
            
         protected:
               
            State
            newState(State state,StateId id)
            {
               return _creator->newState(state, id).first;
            }
            
         public:
            StateInserter() = default;


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

            StateInserter(StateIdGenerator & gen, StateCreator & creator) :
            _stateOf(),
            _generator(Diades::Utils::Ptr<StateIdGenerator>::get(gen)),
            _creator(Diades::Utils::Ptr<StateCreator>::get(creator))
            {
            }

            const Fsm &
            source() const
            {
               return _creator->source();
            }

            Fsm &
            target()
            {
               return _creator->target();
            }

            virtual State
            insertState(State state)
            {
               const auto & stateId = source().getStatePropertyId(state);
               return newState(state, getStateId(stateId));
            }

            virtual StateId
            getStateId(StateId stateId)
            {
               auto it = _stateOf.find(stateId);
               if(it == _stateOf.end())
               {
                  return _stateOf.emplace(stateId, _generator->generate(stateId)).first->second;
               }
               return it->second;
            }
         };
         
         
         
         template<typename _StateIdGenerator, typename _StateCreator, typename StateProperty>
         class ManagedStateInserter: public StateInserter<_StateIdGenerator,_StateCreator>
         {
         public:

            using StateIdGenerator = _StateIdGenerator;
            using StateCreator = _StateCreator;
            using Fsm = typename StateCreator::Fsm;
            using State = typename Fsm::State;
            using StateId = typename Fsm::StatePropertyId;
            using StateIdMap = std::unordered_map<StateId, StateId>;
            using StManager = StatePropertyManager<StateProperty, StateId>;
            using StInserter = StateInserter<_StateIdGenerator,_StateCreator>;
            
         private:
            typename Diades::Utils::Ptr<StManager>::ConstP _sourceStateManager;
            typename Diades::Utils::Ptr<StManager>::P _targetStateManager; 
            
         public:
            ManagedStateInserter() = default;


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

            
            ManagedStateInserter(StateIdGenerator & gen, 
                                 StateCreator & creator,
                                 const StManager & sManager,
                                 StManager & tManager) :
               StInserter(gen,creator),
                    _sourceStateManager(Diades::Utils::Ptr<StManager>::get(sManager)),
                    _targetStateManager(Diades::Utils::Ptr<StManager>::get(tManager))
            {}

            virtual State
            insertState(State state)
            {
               const auto & stateId = StInserter::source().getStatePropertyId(state);
               if(_sourceStateManager->isNullId(stateId))
               {
                  return StInserter::newState(state, StInserter::getStateId(stateId));
               }
               if(_sourceStateManager->hasStatePropertyId(stateId))
               {
                  const auto &  property = _sourceStateManager->getStateProperty(stateId);
                  if(_sourceStateManager->isNull(property))
                  {
                     return StInserter::newState(state, StInserter::getStateId(stateId));
                  }
                  else
                  {
                     if(_targetStateManager->hasStateProperty(property))
                     {
                        return StInserter::newState(state,_targetStateManager->statePropertyId(property));
                     }
                     else
                     {
                        return StInserter::newState(state, StInserter::getStateId(stateId));
                     }
                  }
               }
               return StInserter::newState(state, StInserter::getStateId(stateId));  
            }

           
         };
         
         
         
         
         
      }
   }
}


#endif /* __DIADES__AUTOMATA__EXPERIMENTAL__STATEINSERTER__HH__ */