fsm.hpp

Go to the documentation of this file.

#ifndef FSM_H
#define FSM_H
#include <memory>
#include <stdexcept>
#include <type_traits>
#include "events/subject.h"

namespace Events {
  namespace FSM {
    template<class DataType, typename StateType, typename TransitionType>
    class StateReactor {
      protected:
        std::shared_ptr<DataType> data;
        Subject* subject;
        StateType state_type;
      public:
        StateReactor() = delete;
        StateReactor(const StateType& state_type, const std::shared_ptr<DataType>& data_to_mutate, Subject* subject) : data(data_to_mutate), subject(subject), state_type(state_type) { }

        constexpr StateType getStateType() const noexcept {
          return state_type;
        }

        virtual void enterState() {}
        virtual bool updateState(const double delta, TransitionType& transition_type) { return false; }
        virtual void leaveState() {}

        virtual StateType react(const TransitionType transition) { return (StateType)0; }
    };

    template<typename DataType, typename StateType, typename TransitionType, typename... Reactor>
    class FSM : public std::enable_shared_from_this<FSM<DataType, StateType, TransitionType, Reactor...>> {
      private:
        std::shared_ptr<DataType> data;
        Subject* subject;
        StateType current_state;
        StateType end_state;
        bool is_terminated;

        std::map<StateType, std::shared_ptr<StateReactor<DataType, StateType, TransitionType>>> states;
        bool running;

        template<typename T>
        void unpackReactorAndMakeShared(const std::shared_ptr<T>& t) {
          states[t->getStateType()] = t;
        }

        template<typename T, typename... R>
        void unpackReactorAndMakeShared(const std::shared_ptr<T>& t, const std::shared_ptr<R>&... reactors) {
          states[t->getStateType()] = t;

          unpackReactorAndMakeShared(reactors...);
        }

        template<typename... R>
        void unpackAndConstructReactors() {
          unpackReactorAndMakeShared<R...>(std::make_shared<R>(data, subject)...);
        }

      public:
        FSM() = delete;
        FSM(const std::shared_ptr<DataType>& data_to_mutate, const StateType& begin_state, Subject* subject) : data(data_to_mutate), subject(subject), current_state(begin_state), is_terminated(false), running(false)  {
          if(data_to_mutate == nullptr) {
            throw std::invalid_argument("FSM::data_to_mutate cannot be nullptr");
          }

          unpackAndConstructReactors<Reactor...>();
        }

        FSM(const std::shared_ptr<DataType>& data_to_mutate, const StateType& begin_state, const StateType& end_state, Subject* subject) : data(data_to_mutate), current_state(begin_state), end_state(end_state), is_terminated(true), subject(subject) {
          if(data_to_mutate == nullptr) {
            throw std::invalid_argument("FSM::data_to_mutate cannot be nullptr");
          }

          unpackAndConstructReactors<Reactor...>();
        }

        void transition(const TransitionType transition_type) {
          auto new_state_type = states[current_state]->react(transition_type);
          if(new_state_type != current_state) {
            states[current_state]->leaveState();
            current_state = new_state_type;
            states[current_state]->enterState();
          }
          if(is_terminated && current_state == end_state) {
            running = false;
          }
        }

        constexpr bool inFinalState() const noexcept {
          return is_terminated && current_state == end_state;
        }

        void start() {
          running = true;
        }

        void update(const double delta) {
          if(running) {
            TransitionType t;
            if(states[current_state]->updateState(delta, t)) {
              transition(t);
            }
          }
        }

        void stop() {
          running = false;
        }
    };
  }
}

#endif