statemachine.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* You have been warned!
*
*/
#ifndef ZYPP_NG_BASE_STATEMACHINE_INCLUDED_H
#define ZYPP_NG_BASE_STATEMACHINE_INCLUDED_H
 
#include <zypp-core/zyppng/base/signals.h>
#include <zypp-core/zyppng/base/Base>
 
#include <variant>
#include <tuple>
#include <functional>
#include <memory>
#include <optional>
 
namespace zyppng {
 
  namespace detail {
 
    template <typename T>
    using EventSource = SignalProxy<void()> (T::*)();

    template < class State, class Transitions >
    struct StateWithTransitions {
      using StateType = State;
      Transitions _transitions;
 
      template< typename StateMachine >
      StateWithTransitions ( StateMachine &sm ) : _ptr ( std::make_shared<State>( sm )) { }
      StateWithTransitions ( std::shared_ptr<State> &&s ) : _ptr ( std::move(s) ) {}
 
      // move construction is ok
      StateWithTransitions ( StateWithTransitions &&other ) = default;
      StateWithTransitions &operator= ( StateWithTransitions &&other ) = default;
 
      // no copy construction
      StateWithTransitions ( const StateWithTransitions &other ) = delete;
      StateWithTransitions &operator= ( const StateWithTransitions &other ) = delete;
 
      static constexpr auto stateId = State::stateId;
      static constexpr bool isFinal = State::isFinal;
 
      void enter( ) {
        // keep the pointer around, for we might transition to the next state immediately
        auto keepAlive = _ptr;
        return keepAlive->enter( );
      }
 
      void exit( ) {
        // keep the pointer around, for we might transition to the next state immediately
        auto keepAlive = _ptr;
        return keepAlive->exit( );
      }
 
      std::shared_ptr<State> wrappedState () {
        return _ptr;
      }
 
      const std::shared_ptr<State> wrappedState () const {
        return _ptr;
      }
 
    private:
      // we need to use a std::shared_ptr here so we can correctly reference the object during signal emission
      std::shared_ptr<State> _ptr;
    };
 

    template < template<typename...> typename Templ , typename NewType, typename TupleType, bool condition >
    struct add_type_to_collection;
 
    template < template<typename...> typename Templ, typename NewType, typename ...Types >
    struct add_type_to_collection< Templ, NewType, Templ<Types...>, true > {
      using Type = Templ<Types..., NewType>;
    };
 
    template < template<typename...> typename Templ, typename NewType, typename ...Types >
    struct add_type_to_collection< Templ, NewType, Templ<Types...>, false > {
      using Type = Templ<Types...>;
    };

    template < typename Variant, typename Type, template<typename, typename> typename Compare = std::is_same, size_t I = 0 >
    constexpr bool VariantHasType () {
      // cancel the evaluation if we entered the last type in the variant
      if constexpr ( I >= std::variant_size_v<Variant> ) {
        return false;
      } else {
        // if the current type in the variant is the same as the one we are looking for evaluate to true
        if ( Compare< std::variant_alternative_t< I, Variant>, Type >::value )
          return true;
 
        // otherwise call the next iteration with I+1
        return VariantHasType<Variant, Type, Compare, I+1>();
      }
    }

    template< class State, class TupleSoFar, class Head, class ...Transitions >
    struct collect_transitions_helper {
      using NewTuple = typename add_type_to_collection< std::tuple, Head, TupleSoFar, std::is_same_v< State, typename Head::SourceType> >::Type;
      using Type = typename collect_transitions_helper<State, NewTuple, Transitions...>::Type;
    };
 
    template< class State, class TupleSoFar, class Head >
    struct collect_transitions_helper<State, TupleSoFar, Head > {
      using Type = typename add_type_to_collection< std::tuple, Head, TupleSoFar, std::is_same_v< State, typename Head::SourceType> >::Type;
    };
 
    template< class State, class ...Transitions >
    struct collect_transitions{
      using Type = typename collect_transitions_helper< State, std::tuple<>, Transitions... >::Type;
    };

    template <typename VariantSoFar, typename Head, typename ...Transitions>
    struct make_state_set_helper {
      using WithSource = typename add_type_to_collection< std::variant, typename Head::SourceType, VariantSoFar, !VariantHasType<VariantSoFar, typename Head::SourceType>() >::Type;
      using WithTarget = typename add_type_to_collection< std::variant, typename Head::TargetType, WithSource, !VariantHasType<WithSource, typename Head::TargetType>() >::Type;
      using Type = typename make_state_set_helper<WithTarget, Transitions...>::Type;
    };
 
    template <typename VariantSoFar, typename Head>
    struct make_state_set_helper< VariantSoFar, Head > {
      using WithSource = typename add_type_to_collection< std::variant, typename Head::SourceType, VariantSoFar, !VariantHasType<VariantSoFar, typename Head::SourceType>() >::Type;
      using Type = typename add_type_to_collection< std::variant, typename Head::TargetType, WithSource, !VariantHasType<WithSource, typename Head::TargetType>() >::Type;
    };
 
    template <typename Head, typename ...Transitions>
    struct make_state_set {
      using InitialVariant = std::variant<typename Head::SourceType>;
      using VariantSoFar = typename add_type_to_collection< std::variant, typename Head::TargetType, InitialVariant , !VariantHasType<InitialVariant, typename Head::TargetType>() >::Type;
      using Type = typename make_state_set_helper< VariantSoFar, Transitions...>::Type;
    };
 

    template <typename A, typename B>
    struct is_same_state : public std::is_same< typename A::StateType, typename B::StateType> {};
 

    template <typename State, typename ...Transitions>
    struct make_statewithtransition {
      using Type = StateWithTransitions<State, typename collect_transitions<State, Transitions...>::Type>;
    };

    template <typename VariantSoFar, typename StateVariant, typename ...Transitions>
    struct make_statewithtransition_set_helper;
 
    template <typename VariantSoFar, typename HeadState, typename ...State, typename ...Transitions>
    struct make_statewithtransition_set_helper< VariantSoFar, std::variant<HeadState, State...>, Transitions... > {
      using FullStateType = typename make_statewithtransition<HeadState, Transitions...>::Type;
      using NewVariant = typename add_type_to_collection< std::variant, FullStateType, VariantSoFar, !VariantHasType<VariantSoFar, FullStateType/*, is_same_state */>()>::Type;
      using Type = typename make_statewithtransition_set_helper< NewVariant, std::variant<State...>, Transitions...>::Type;
    };
 
    template <typename VariantSoFar, typename HeadState, typename ...Transitions >
    struct make_statewithtransition_set_helper< VariantSoFar, std::variant<HeadState>, Transitions... > {
      using FullStateType = typename make_statewithtransition<HeadState, Transitions...>::Type;
      using Type = typename add_type_to_collection< std::variant, FullStateType, VariantSoFar, !VariantHasType<VariantSoFar, FullStateType /*, is_same_state */>()>::Type;
    };
 
    template <typename NoState, typename StateVariant, typename ...Transitions>
    struct make_statewithtransition_set;
 
    template <typename NoState, typename HeadState, typename ...States, typename ...Transitions>
    struct make_statewithtransition_set< NoState, std::variant<HeadState, States...>, Transitions...>{
      using FirstState = typename make_statewithtransition< HeadState, Transitions...>::Type;
      using Type = typename make_statewithtransition_set_helper< std::variant<NoState, FirstState>, std::variant<States...>, Transitions...>::Type;
    };
  }
 
  constexpr bool DefaultStateCondition(true);
  constexpr std::nullptr_t DefaultStateTransition(nullptr);

  template <
    typename Source,
    detail::EventSource<Source> ev ,
    typename Target,
    auto Cond = DefaultStateCondition,
    auto Op   = DefaultStateTransition >
  struct Transition {
 
    using SourceType = Source;
    using TargetType = Target;
 
 
    template< typename Statemachine >
    std::shared_ptr<Target> operator() ( Statemachine &sm, Source &oldState ) {
      using OpType = std::decay_t<decltype ( Op )>;
      // check if we have a member function pointer
      if constexpr (  std::is_member_function_pointer_v<OpType> ) {
        return std::invoke( Op, &oldState );
      } else if constexpr ( std::is_null_pointer_v<OpType> ) {
        return std::make_shared<Target>(sm);
      } else {
        return std::invoke( Op, sm, oldState );
      }
    }
 
    bool checkCondition ( Source &currentState ) {
      using CondType = std::decay_t<decltype ( Cond )>;
      if constexpr ( std::is_same_v<bool, CondType> ) {
        return Cond;
      } else if constexpr ( std::is_member_function_pointer_v<CondType> ) {
        return std::invoke( Cond, &currentState );
      } else {
        return std::invoke( Cond, currentState );
      }
    }
 
    SignalProxy< void() > eventSource ( Source *st ) {
      return std::invoke( ev, st );
    }
 
    auto eventAccessor () const {
      return ev;
    }
 
  };

  template < typename Derived, typename StateId, typename ...Transitions >
  class Statemachine {
 
    struct _InitialState{};
 
  public:
 
    using AllStates = typename detail::make_state_set< Transitions... >::Type;
    using StateSetHelper = typename detail::make_statewithtransition_set< _InitialState, AllStates, Transitions... >;
    using FState = typename StateSetHelper::FirstState;
    using StateSet = typename StateSetHelper::Type;
 
    using StatemachineType = Statemachine< Derived, StateId, Transitions...>;
 
    public:
      Statemachine () { }
      virtual ~Statemachine() {}

      void start () {
        if ( _state.index() == 0 || _isInFinalState ) {
          _previousState.reset();
          _isInFinalState = false;
          _emittedFinalSig = false;
          enterState( FState( static_cast<Derived &>(*this) ) );
        }
      }
 
      template <typename Func>
      auto visitState ( Func && f ) {
        return std::visit( [ func = std::forward<Func>(f) ] ( auto &s ) {
          using T = std::decay_t<decltype (s)>;
          if constexpr ( std::is_same_v< T, _InitialState > ) {
            throw std::exception();
          } else {
            auto lock = s.wrappedState();
            return ( func( *lock ) );
          }
        }, _state );
      }

      std::optional<StateId> currentState () const {
        return std::visit( []( const auto &s ) -> std::optional<StateId> {
          using T = std::decay_t<decltype (s)>;
          if constexpr ( std::is_same_v< T, _InitialState > ) {
            return {};
          } else {
            return T::stateId;
          }
        }, _state );
      }

      std::optional<StateId> previousState () const {
        return _previousState;
      }

      template<typename T>
      std::shared_ptr<T> state () {
        using WrappedEventType = typename detail::make_statewithtransition< std::decay_t<T>, Transitions...>::Type;
        return std::get<WrappedEventType>( _state ).wrappedState();
      }

      template<typename T>
      const std::shared_ptr<T> state () const {
        using WrappedEventType = typename detail::make_statewithtransition< std::decay_t<T>, Transitions...>::Type;
        return std::get<WrappedEventType>( _state ).wrappedState();
      }

      template <typename NewState >
      void forceState ( std::unique_ptr<NewState> &&nS ) {
        using WrappedSType = typename detail::make_statewithtransition< std::decay_t<NewState>, Transitions...>::Type;
        std::visit( [this, &nS]( auto &currState ) {
          using T = std::decay_t<decltype (currState)>;
          if constexpr ( std::is_same_v< T, WrappedSType > ) {
            return;
          } else if constexpr ( std::is_same_v< T, _InitialState > ) {
            enterState ( WrappedSType( std::move(nS) ) );
          } else {
            enterState ( currState, WrappedSType( std::move(nS) ) );
          }
        }, _state );
      }

      SignalProxy<void()> sigFinished () {
        return _sigFinished;
      }

      SignalProxy<void ( StateId )> sigStateChanged () {
        return _sigStateChanged;
      }
 
    protected:
 
      template <typename OldState, typename NewState>
      void enterState ( OldState &os, NewState &&nS ) {
        // disconnect all signals from the current state
        clearConnections();
        std::forward<OldState>(os).exit();
        _previousState = OldState::stateId;
        enterState( std::forward<NewState>(nS) );
      }
 
      template <typename NewState>
      void enterState ( NewState &&nS ) {
 
        if constexpr ( !NewState::isFinal ) {
          connectAllTransitions<0>( nS, nS._transitions );
        }
 
        _state.template emplace<NewState>( std::forward<NewState>(nS) );
 
        // handle final state things
        if constexpr ( NewState::isFinal ) {
          _isInFinalState = true;
          _emittedFinalSig = false;
        }
 
        // let the outside world know whats going on
        _sigStateChanged.emit( NewState::stateId  );
 
        // call enter on the state as the last thing to do, it might emit a transition event right away
        std::get< std::decay_t<NewState> >( _state ).enter();
 
        // emit the final signal, but only if it was not already emitted by a subsequent transition
        if ( _isInFinalState && !_emittedFinalSig ) {
          _emittedFinalSig = true;
          _sigFinished.emit();
        }
 
      }
 
      template <typename State, typename Transition>
      auto makeEventCallback ( Transition &transition ) {
        using WrappedEventType = typename detail::make_statewithtransition< typename Transition::TargetType, Transitions...>::Type;
        return [ mytrans = &transition, this]() mutable {
          auto stateLock = std::get< std::decay_t<State> >(_state).wrappedState();
          if ( mytrans->checkCondition( *stateLock ) ) {
            auto &st = std::get< std::decay_t<State> >(_state);
            enterState( st , WrappedEventType( (*mytrans)( static_cast<Derived &>(*this), *stateLock ) ) );
          }
        };
      }
 
      template< std::size_t I = 0, typename State, typename ...StateTrans>
      void connectAllTransitions( State &&nS, std::tuple<StateTrans...> &transitions ) {
        if constexpr (I >= sizeof...(StateTrans)) {
          return;
        } else {
          auto &transition = std::get<I>( transitions );
          //_currentStateConnections.push_back( transition.eventSource ( std::forward<State>(nS).wrappedState().get() ).connect( makeEventCallback< std::decay_t<State> >(transition)) );
          _currentStateConnections.push_back( std::forward<State>(nS).wrappedState()->Base::connectFunc( transition.eventAccessor(), makeEventCallback< std::decay_t<State> >(transition), *static_cast<Derived*>(this) ) );
          connectAllTransitions<I+1>( std::forward<State>(nS), transitions );
        }
      }
 
      void clearConnections () {
        for ( auto &c : _currentStateConnections )
          c.disconnect();
        _currentStateConnections.clear();
      }
 
    private:
      bool _isInFinalState = false;
      bool _emittedFinalSig = false; //< Flag to make sure the finished signals is only emitted once
      Signal <void ( StateId )> _sigStateChanged;
      Signal <void ()> _sigFinished;
      StateSet _state = _InitialState();
      std::optional<StateId> _previousState;
      std::vector<sigc::connection> _currentStateConnections;
  };

  template < typename StatemachineType, bool isFin >
  class BasicState : public Base {
  public:
 
    static constexpr bool isFinal = isFin;
 
    BasicState( StatemachineType &sm ) : _sm( sm ){}
    ~BasicState() override {}
 
    BasicState( BasicState && ) noexcept = default;
    BasicState &operator= ( BasicState && ) noexcept = default;
 
    StatemachineType &stateMachine () {
      return _sm;
    }
 
    const StatemachineType &stateMachine () const {
      return _sm;
    }
 
  private:
    StatemachineType &_sm;
 
  };

  template < typename StatemachineType, auto sId, bool isFin >
  class SimpleState : public BasicState<StatemachineType, isFin> {
    public:
      static constexpr auto stateId = sId;
      using BasicState<StatemachineType, isFin>::BasicState;
  };
 
}
 
#endif // ZYPP_NG_BASE_STATEMACHINE_INCLUDED_H