SPAR/AIModule/SparAIModule/Utils/FSM/FSMState.h

Go to the documentation of this file.

#pragma once
#include "IFSMState.h"
#include "Transition.h"
#include "FSM.h"
#include <boost/tuple/tuple.hpp>

template <class FSM, class DerivedState>
class FSMState : public IFSMState
{
public:
  FSMState(FSM &context)
    : m_context(context)
    , m_earliestNextTransitionFrame(0)
  {
  }

  virtual ~FSMState()
  {
  }

  std::string getName() const
  {
    // Could be done during compilation ;-)
    std::string fullName(typeid(DerivedState).name());
    size_t begin = fullName.find_last_of("::");
    if (begin == std::string::npos)
      begin = 0;
    else
      ++begin;
    return fullName.substr(begin);
  }

  virtual void externalTerminate()
  {
    onExit();
  }

  void onEnter()
  {
    m_context.setCurrentState(this);

    static_cast<DerivedState*>(this)->onEnterImpl();

    if (m_context.isExecuting())
    {
      enableTransitions();
    }
  }

  void onExit()
  {
    assert(m_context.m_currentState != NULL);

    static_cast<DerivedState*>(this)->onExitImpl();

    disableTransitions();

    m_context.onExitState();

#ifdef _DEBUG_COMPONENT
    verifyPendingSubscriptions("ERROR FSMState::onExit(): Make sure to unsubscribe EventHandler \"%s\" from event \"%s\" when the FSM switches states.");

    verifyPendingTasks("ERROR FSMState::onExit(): Make sure to deactivate task \"%s\" when the FSM switches states.");
#endif

    m_stateExitEvent.raise();
  }

  size_t getEarliestNextTransitionFrame() const
  {
    return m_earliestNextTransitionFrame;
  }

  void setEarliestNextTransitionFrame(size_t earliestAllowedFrameNumber)
  {
    m_earliestNextTransitionFrame = earliestAllowedFrameNumber;
  }

protected:
  template <size_t size>
  struct EventsHelper
  {
    static void activate(const FSMState& state)
    {
      boost::get<size-1>(static_cast<const DerivedState&>(state).m_events).activate();
      EventsHelper<size-1>::activate(state);
    }
    static void deactivate(const FSMState& state)
    {
      boost::get<size-1>(static_cast<const DerivedState&>(state).m_events).deactivate();
      EventsHelper<size-1>::deactivate(state);
    }
  };
  template <>
  struct EventsHelper<0>
  {
    static void activate(const FSMState&) {}
    static void deactivate(const FSMState&) {}
  };

  void enableTransitions()
  {
    EventsHelper<boost::tuples::length<DerivedState::Events>::value>::activate(*this);
  }

  void disableTransitions()
  {
    EventsHelper<boost::tuples::length<DerivedState::Events>::value>::deactivate(*this);
  }

  // Problem: "Events m_events" and "Transitions m_transitions" cannot be stored in here as DerivedType is
  // not yet defined in FSMState<DerivedState> (so they must be defined in derived classes instead).

  FSM &m_context;

  size_t m_earliestNextTransitionFrame;

private:
  FSMState(const FSMState& other);
};