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

Go to the documentation of this file.

#pragma once
#include "../SafeListAdaptor.h"
#include "../Process.h"
#include "../Event.h"
#include <list>
#include <boost/iterator/transform_iterator.hpp>

class IFSMState;

class IFSM : public virtual Process
{
public:
  friend class IFSMState;
  template <class FSM, class DerivedState> friend class FSMState;
  //typedef boost::transform_iterator<extract_fsm, typename SafeListAdaptor<FSMWrapper*>::const_iterator> sub_fsm_const_iterator;
  //typedef boost::transform_iterator<extract_fsm, typename SafeListAdaptor<FSMWrapper*>::iterator> sub_fsm_iterator;

  IFSM(const Process* parent)
    : Process(parent)
    , m_currentState(NULL)
  {
  }

  virtual ~IFSM()
  {
    assert(m_currentState == NULL);
  }

  // DON'T CALL THESE METHODS IF A SUB-FSM MAY BE ADDED/REMOVED!
  //sub_fsm_const_iterator subFSMBegin() const { return sub_fsm_const_iterator(ConstSafeListAdaptor<FSMWrapper*>(m_subFSMs).unsafe_begin()); }
  //sub_fsm_const_iterator subFSMEnd() const { return sub_fsm_const_iterator(ConstSafeListAdaptor<FSMWrapper*>(m_subFSMs).unsafe_end()); }

  //const IFSMState* getCurrentState() const
  //{
  //  return m_currentState;
  //}

  // GUI //
  virtual std::vector<const IFSMState*> getAllStates() const = 0;
  const IFSMState* getCurrentState() const
  {
    return m_currentState;
  }

protected:
  // DON'T CALL THESE METHODS IF A SUB-FSM MAY BE ADDED/REMOVED!
  //sub_fsm_iterator subFSMBegin() { return sub_fsm_iterator(SafeListAdaptor<FSMWrapper*>(m_subFSMs).unsafe_begin()); }
  //sub_fsm_iterator subFSMEnd() { return sub_fsm_iterator(SafeListAdaptor<FSMWrapper*>(m_subFSMs).unsafe_end()); }

  void setCurrentState(IFSMState* currentState)
  {
    m_currentState = currentState;
  }

  virtual void terminateImpl();

  void onExitState()
  {
    m_currentState = NULL;
    for_each_child_process(TerminateProcess());

    assert(getNbChildProcesses() == 0);
    //m_subFSMs.clear();
  }

  //
  // Variables
  //

  IFSMState* m_currentState;

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

template <class DerivedFSM>
class FSM : public virtual IFSM
{
public:
  FSM(const Process* parent)
    : IFSM(parent)
    , Process(parent)
  {}

  // GUI //
  virtual std::vector<const IFSMState*> getAllStates() const
  {
    std::vector<const IFSMState*> states(boost::tuples::length<DerivedFSM::States>::value);
    StatesHelper<boost::tuples::length<typename DerivedFSM::States>::value>::copy(*this, states);
    
    return states;
  }

private:
  template <size_t i>
  struct StatesHelper
  {
    static void copy(const FSM& fsm, std::vector<const IFSMState*>& states)
    {
      states[i-1] = &boost::get<i-1>(static_cast<const DerivedFSM&>(fsm).m_states);
      StatesHelper<i-1>::copy(fsm, states);
    }
  };
  template <>
  struct StatesHelper<0>
  {
    static void copy(const FSM&, std::vector<const IFSMState*>&) {}
  };
};