StateCreation.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__STATECREATION__HH
#define __DIADES__AUTOMATA__EXPERIMENTAL__STATECREATION__HH

#include<diades/utils/Iterator.hh>
#include<diades/utils/Exceptions.hh>
#include<diades/utils/Assertion.hh>
#include<diades/automata/experimental/StateMachine.hh>
#include<diades/automata/experimental/StatePropertyManager.hh>
#include<diades/automata/experimental/BeliefState.hh>

namespace Diades {
    namespace Automata {
        namespace Experimental {
            using Diades::Utils::Ptr;

            template<typename _StateMachine>
            class StateCreation { 
            public:

                static string
                typeName() {
                    return "Automata::StateCreation";
                }
                using Exception = Diades::Utils::Exception<StateCreation>;
            public:
                using Fsm = _StateMachine;
                using StatePropertyId = typename Fsm::StatePropertyId;
                using EventPropertyId = typename Fsm::EventPropertyId;

                using State = typename Fsm::State;

            protected:
                const Fsm & _source;
                Fsm & _target;
            public:

                StateCreation(const Fsm & source, Fsm & target) :
                _source(source), _target(target) {

                }

                const Fsm &
                source() const {
                    return _source;
                }

                const Fsm &
                target() const {
                    return _target;
                }

                Fsm &
                target() {
                    return _target;
                }


            };

            template<typename StateMachine>
            class NewStateCreation : public StateCreation<StateMachine> {
            public:
                using SC = StateCreation<StateMachine>;

            public:

                NewStateCreation(const StateMachine & source, StateMachine & target) :
                SC(source, target) {
                }

                virtual std::pair<typename SC::State, bool>
                newState(typename SC::State source) {
                    return SC::_target->newState();
                }


            };

            template<typename StateMachine>
            class StateCopy : public StateCreation<StateMachine> {
            public:
                using SC = StateCreation<StateMachine>;

            public:

                StateCopy(const StateMachine & source, StateMachine & target) :
                SC(source, target) {
                }

                virtual std::pair<typename SC::State, bool>
                newState(typename SC::State source) {
                    auto result = SC::target().newState(SC::source().getStatePropertyId(source));
                    if (SC::source().isInitial(source)) {
                        SC::target().setInitial(result.first);
                    }
                    return result;
                }

                virtual std::pair<typename SC::State, bool>
                newState(typename SC::State source, const typename SC::StatePropertyId & statePropertyId) {
                    auto result = SC::target().newState(statePropertyId);
                    if (SC::source().isInitial(source)) {
                        SC::target().setInitial(result.first);
                    }
                    return result;
                }
            };

            template<typename StateMachine, typename _StateProperty>
            class ManagedStateCreation : public StateCreation<StateMachine> {
            public:
                using SC = StateCreation<StateMachine>;
                using Fsm = typename SC::Fsm;
                using StateProperty = _StateProperty;
                using StatePropertyId = typename SC::StatePropertyId;
                using StManager = StatePropertyManager<StateProperty, StatePropertyId>;
            private:
                const StManager & _sourceStateManager;
                StManager & _targetStateManager;

            public:

                const StManager &
                sourceStateManager() const {
                    return _sourceStateManager;
                }

                StManager &
                targetStateManager() {
                    return _targetStateManager;
                }
            public:

                ManagedStateCreation(const Fsm & source, Fsm & target,
                        const StManager & sourceStateManager,
                        StManager & targetStateManager) :
                SC(source, target),
                _sourceStateManager(sourceStateManager),
                _targetStateManager(targetStateManager) {
                }

            };

            template<typename StateMachine, typename StateProperty>
            class ManagedStateCopy : public ManagedStateCreation<StateMachine, StateProperty> {
            public:

            public:
                using MSC = ManagedStateCreation<StateMachine, StateProperty>;
                using Fsm = typename MSC::Fsm;
                using StManager = typename MSC::StManager;
                using State = typename MSC::State;
                using StatePropertyId = typename MSC::StatePropertyId;

                ManagedStateCopy(const Fsm & source,
                        Fsm & target,
                        const StManager & sourceStateManager,
                        StManager & targetStateManager) :
                MSC(source, target, sourceStateManager, targetStateManager) {
                }

                virtual std::pair<State, bool>
                newState(State source) {
                    auto propId = MSC::source().getStatePropertyId(source);
                    std::pair<State, bool> result;
                    if (propId != MSC::source().nullStatePropertyId) {
                        if (MSC::sourceStateManager().hasStatePropertyId(propId)) {
                            result = MSC::target().newState(MSC::targetStateManager().statePropertyId(MSC::sourceStateManager().getStateProperty(propId)));
                        } else {
                            result = MSC::target().newState(propId);
                        }
                    } else {
                        result = MSC::target().newState(MSC::source().nullStatePropertyId);
                    }
                    if (MSC::source().isInitial(source)) {
                        MSC::target().setInitial(result.first);
                    }
                    return result;
                }

                virtual std::pair<State, bool>
                newState(State source, const StatePropertyId & statePropertyId) {
                    auto propId = MSC::source().getStatePropertyId(source);
                    std::pair<State, bool> result;
                    if (propId != MSC::source().nullStatePropertyId) {

                        if (MSC::sourceStateManager().hasStatePropertyId(propId)) {
                            const auto & property = MSC::sourceStateManager().getStateProperty(propId);
                            if (!MSC::sourceStateManager().isNull(property)) {
                                // here the source state is associated with a non-null StateProperty
                                // let us check whether the target manager know about this StateProperty

                                if (!MSC::targetStateManager().hasStateProperty(property)) {
                                    // the target manager does not know about this StateProperty
                                    if (MSC::targetStateManager().setStateProperty(property, statePropertyId)) {
                                        // all is fine, new StateProperty set to a new StatePropertyId, ready to
                                        // create a new State for this new StatePropertyId
                                        result = MSC::target().newState(statePropertyId);
                                    } else {
                                        // aya ! The StatePropertyId that is given is
                                        // already associated with a StateProperty in the manager and it is wrong one, 
                                        //I give up!
                                        always_require(MSC::Exception, false,
                                                "newState (ManagedStateCopy): attempting to create a state associated with a StatePropertyId already assigned to a StateProperty that is not the StateProperty of the source state");
                                    }
                                } else {
                                    // the target manager knows the StateProperty
                                    // so actually the StateProperty is already associated with a StatePropertyId
                                    // in target, that identifies one and only one State in the result
                                    result = MSC::target().newState(MSC::targetStateManager().statePropertyId(property));
                                }
                            } else {
                                // here, the StateManager associated with the source fsm 
                                // knows the StatePropertyId but is associated with a null property
                                // so here I consider that in the target the StateManager
                                // does not know any StateProperty and the target state
                                // is the null StatePropertyId
                                result = std::pair(MSC::target().newState(), true);

                            }
                        } else {
                            // here, the StateManager associated with the source fsm 
                            // does not know the StatePropertyId while it is not null
                            // so here I consider that in the target the StateManager
                            // does not know any StateProperty and the target state
                            // is the null StatePropertyId
                            result = std::pair(MSC::target().newState(), true);
                        }
                    } else {
                        // the source state is associated to a null StatePropertyId, so should be 
                        // the target state
                        result = std::pair(MSC::target().newState(), true);
                    }
                    if (MSC::source().isInitial(source)) {
                        MSC::target().setInitial(result.first);
                    }
                    return result;
                }
            };

            template<typename StateMachine>
            class BeliefStateWithSourceStateCreator {
            public:

                using StatePropertyId = typename StateMachine::StatePropertyId;
                using State = typename StateMachine::State;
                using FsmBs = BeliefState<StateMachine>;
            public:



                virtual std::pair<State, bool>
                newState(State source, const FsmBs & bs) = 0;
            };

            template<typename StateMachine>
            class BeliefStateBasedStateCreator {
            public:

                using StatePropertyId = typename StateMachine::StatePropertyId;
                using State = typename StateMachine::State;
                using FsmBs = BeliefState<StateMachine>;
            public:



                virtual std::pair<State, bool>
                newState(const FsmBs & bs) = 0;
            };

            template<typename StateMachine>
            class OnlySourceStateCreator : public StateCreation<StateMachine>,
            public BeliefStateWithSourceStateCreator<StateMachine> {
            public:
                using SC = StateCreation<StateMachine>;
                using BSSSC = BeliefStateWithSourceStateCreator<StateMachine>;
                using State = typename SC::State;
                using FsmBs = typename BSSSC::FsmBs;
            public:

                OnlySourceStateCreator(const StateMachine & source, StateMachine & target) :
                SC(source, target), BSSSC() {
                }

                virtual std::pair<State, bool>
                newState(State source, const FsmBs & bs) {
                    // why using StateCreation<StateMachine>::_target instead of _target? Does not compile
                    // see https://gcc.gnu.org/onlinedocs/gcc/Name-lookup.html for explanation

                    // here we do not take into account the belief state of source
                    return SC::_target.newState(SC::_source.getStatePropertyId(source));
                }
            };

            template<typename StateMachine, typename StatePropertyCombination>
            class ManagedBeliefStateWithSourceStateCreator :
            public ManagedStateCreation< StateMachine, typename StatePropertyCombination::StateProperty>,
            public BeliefStateWithSourceStateCreator<StateMachine> {
            public:
                using BSSSC = BeliefStateWithSourceStateCreator<StateMachine>;
                using MSC = ManagedStateCreation< StateMachine, typename StatePropertyCombination::StateProperty>;
                using State = typename MSC::State;
                using FsmBs = typename BSSSC::FsmBs;
                using StatePropertyId = typename MSC::StatePropertyId;
                using StateProperty = typename MSC::StateProperty;

                ManagedBeliefStateWithSourceStateCreator(const StateMachine & source, StateMachine & target,
                        const StatePropertyManager<StateProperty, StatePropertyId> & sourceStateManager,
                        StatePropertyManager<StateProperty, StatePropertyId> & targetStateManager) :
                MSC(source, target, sourceStateManager, targetStateManager), BSSSC() {
                }

                virtual std::pair<State, bool>
                newState(State source, const FsmBs & bs) {

                    // get the iterator of the StatePropertyId associated with the state *bs.begin() in _source
                    auto begin = MSC::sourceStateManager().infoIdRangeInfoIterator(MSC::_source.statePropertyIdRangeIterator(bs.begin()));
                    // get the iterator of the StatePropertyId associated with the-after-the-last-state bs.end() in _source
                    auto end = MSC::sourceStateManager().infoIdRangeInfoIterator(MSC::_source.statePropertyIdRangeIterator(bs.end()));
                    // creation of the new StateProperty compatible with the projection as specified in StatePropertyProjection
                    auto statePropertyId = MSC::targetStateManager().statePropertyId(
                            StatePropertyCombination()(MSC::sourceStateManager().getStateProperty(MSC::_source.getStatePropertyId(source)),
                            begin, end));
                    // create the state in target with the statePropertyId created in the _projectionStateManager
                    return MSC::_target.newState(statePropertyId);
                }

            };

            template<typename StateMachine>
            class OnlyStateCreator : public StateCreation<StateMachine>,
            public BeliefStateBasedStateCreator<StateMachine> {
            public:
                using SC = StateCreation<StateMachine>;
                using BSBSC = BeliefStateBasedStateCreator<StateMachine>;
                using State = typename SC::State;
                using FsmBs = typename BSBSC::FsmBs;
            public:

                OnlyStateCreator(const StateMachine & source, StateMachine & target) :
                SC(source, target), BSBSC() {
                }

                virtual std::pair<State, bool>
                newState(const FsmBs & bs) {
                    // why using StateCreation<StateMachine>::_target instead of _target? Does not compile
                    // see https://gcc.gnu.org/onlinedocs/gcc/Name-lookup.html for explanation

                    // here we do not take into account the belief state of source
                    return std::make_pair(SC::_target.newState(), true);
                }
            };

            template<typename StateMachine, typename StatePropertyCombination>
            class ManagedBeliefStateBasedStateCreator :
            public ManagedStateCreation<StateMachine, typename StatePropertyCombination::Property>,
            public BeliefStateBasedStateCreator<StateMachine> {
            public:
                using MSC = ManagedStateCreation<StateMachine, typename StatePropertyCombination::Property>;
                using BSBSC = BeliefStateBasedStateCreator<StateMachine>;
                using State = typename MSC::State;
                using FsmBs = typename BSBSC::FsmBs;
                using StatePropertyId = typename MSC::StatePropertyId;
                using StateProperty = typename MSC::StateProperty;

            public:

                ManagedBeliefStateBasedStateCreator(const StateMachine & source, StateMachine & target,
                        const StatePropertyManager<StateProperty, StatePropertyId> & sourceStateManager,
                        StatePropertyManager<StateProperty, StatePropertyId> & targetStateManager) :
                MSC(source, target, sourceStateManager, targetStateManager), BSBSC() {
                }

                virtual std::pair<State, bool>
                newState(const FsmBs & bs) {
                    // get the iterator of the StatePropertyId associated with the state *bs.begin() in _source
                    auto begin = MSC::sourceStateManager().infoIdRangeInfoIterator(MSC::_source.statePropertyIdRangeIterator(bs.begin()));
                    // get the iterator of the StatePropertyId associated with the-after-the-last-state bs.end() in _source
                    auto end = MSC::sourceStateManager().infoIdRangeInfoIterator(MSC::_source.statePropertyIdRangeIterator(bs.end()));
                    // creation of the new StateProperty compatible with the projection as specified in StatePropertyProjection
                    auto statePropertyId = MSC::targetStateManager().statePropertyId(
                            StatePropertyCombination()(begin, end));
                    // create the state in target with the statePropertyId created in the _projectionStateManager
                    return MSC::_target.newState(statePropertyId);
                }

            };

            template<typename T>
            struct StateCreationTraits;

            template<typename T1, typename T2>
            struct StateCreationTraits<ManagedStateCreation<T1, T2>>
            {

                static constexpr bool isManaged() {
                    return true;
                }
            };

            template<typename T1>
            struct StateCreationTraits<StateCreation<T1>>
            {

                static constexpr bool isManaged() {
                    return false;
                }
            };

            template<typename _StateMachine, typename _StateProperty, typename StatePropertyCombination>
            class ManagedSynchronisedStateCreation {
            public:

                using StateMachine = _StateMachine;

                using StatePropertyId = typename StateMachine::StatePropertyId;

                using StateProperty = _StateProperty;

                using SManager = StatePropertyManager<StateProperty, StatePropertyId>;

                using State = typename StateMachine::State;

            protected:
                typename Ptr<std::vector< typename Ptr<StateMachine>::ConstP> >::ConstP _machines;


                typename Ptr<std::vector< typename Ptr<SManager>::ConstP>>::ConstP _managers;


                typename Ptr<SManager>::P _syncManager;

                typename Ptr<StateMachine>::P _target;


                typename Ptr<std::vector<State>>::ConstP _pstates;

            public:

                ManagedSynchronisedStateCreation(const std::vector<typename Ptr<StateMachine>::ConstP> & machines,
                        const std::vector<typename Ptr<SManager>::ConstP> & managers,
                        SManager & syncManager)
                : _machines(Ptr<std::vector<typename Ptr<StateMachine>::ConstP>>::get(machines)),
                _managers(Ptr<std::vector<typename Ptr<SManager>::ConstP>>::get(managers)),
                _syncManager(Ptr<SManager>::get(syncManager)),
                _target(nullptr),
                _pstates(nullptr) {
                }

                void
                setStateMachine(StateMachine & target) {
                    _target = Ptr<StateMachine>::get(target);
                }

            private:

                class GetStateProperty {
                public:
                    using Data = StateProperty;
                    using Iterator = size_t;

                    using MapStructure = ManagedSynchronisedStateCreation;

                    const Data & operator()(const MapStructure & m, size_t index) const {
                        return m._managers->at(index)->getStateProperty(m._machines->at(index)->getStatePropertyId(m._pstates->at(index)));
                    }
                };

            public:

                virtual std::pair<State, bool>
                newState(const std::vector<State> & states) {
                    /*
                     * If no target, no state is created
                     */
                    if (_target == nullptr) {
                        return std::pair<State, bool>(State(), false);
                    }

                    /*
                     * Storing the current state vector before using GetStateProperty
                     */
                    _pstates = Ptr<std::vector < State>>::get(states);

                    /*
                     * The range of StateProperties will be accessed with the help
                     * of a RangeMapperIterator (from diades/utils/Iterator.hh)
                     * The Mapper for this RangeMapperIterator is a GetStateProperty functor
                     * The Iterator is simply the size_t index of the states vector
                     * 
                     * The range is defined by [begin,end[
                     */
                    using Diades::Utils::RangeMapperIterator;
                    RangeMapperIterator<GetStateProperty> begin(*this, 0);
                    RangeMapperIterator<GetStateProperty> end(*this, states.size());



                    /*
                     * Creation of the statePropertyId by that syncManager resulting from
                     * the created StateProperty. The created StateProperty is a combination
                     * of the local StateProperty's from the current local states
                     */
                    auto statePropertyId = _syncManager->statePropertyId(StatePropertyCombination()(begin, end));

                    /*
                     * effective creation of the State associated with statePropertyId if needed.
                     */
                    return _target->newState(statePropertyId);
                }
            };

        }
    }
}


#endif /* __DIADES__AUTOMATA__EXPERIMENTAL__STATECREATION__HH */