RTC_Utils::StateMachine< State, Listener, States, Callback > Class Template Reference

State machine class. More...

#include <StateMachine.h>

List of all members.

Public Member Functions
	StateMachine (int num_of_state)
	Constructor.
virtual	~StateMachine ()
void	setNOP (Callback call_back)
	Set NOP function.
void	setListener (Listener *listener)
	Set Listener Object.
bool	setEntryAction (State state, Callback call_back)
	Set Entry action function.
bool	setPreDoAction (State state, Callback call_back)
	Set PreDo action function.
bool	setDoAction (State state, Callback call_back)
	Set Do action function.
bool	setPostDoAction (State state, Callback call_back)
	Set PostDo action function.
bool	setExitAction (State state, Callback call_back)
	Set Exit action function.
bool	setTransitionAction (Callback call_back)
	Set state transition action function.
void	setStartState (States states)
	Set the initial state.
States	getStates ()
	Get states.
State	getState ()
	Get current state.
bool	isIn (State state)
	Check current state.
void	goTo (State state)
	Transit State.
void	worker ()
	Worker function.
Protected Member Functions
void	setNullFunc (Callback *s, Callback nullfunc)
	Set NOP function.
Protected Attributes
int	m_num
	Number of state.
Listener *	m_listener
	Callback function for listener.
Callback *	m_entry
	Callback function for Entry action.
Callback *	m_predo
	Callback function for PreDo action.
Callback *	m_do
	Callback function for Do action.
Callback *	m_postdo
	Callback function for PostDo action.
Callback *	m_exit
	Callback function for Exit action.
Callback	m_transit
	Callback function for State transition action.
States	m_states
	Current state information.
bool	m_selftrans
Mutex	m_mutex

---

Detailed Description

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>
class RTC_Utils::StateMachine< State, Listener, States, Callback >

State machine class.

StateMachine class is a class to realize a state machine.

Example: ActiveObject assumes to be an active object that has the state machine. There are three states such as INACTIVE, ACTIVE and ERROR state, and if you want to define Entry or Exit action, this class will realize as follows:

 class ActiveObject 
 {  
 public: 
   enum MyState { INACTIVE, ACTIVE, ERROR }; 
   typedef States<MyState> MyStates;

   ActiveObject() 
     : m_sm(3) 
   { 
     m_sm.setNOP(&ActiveObject::nullAction); 
     m_sm.setListener(this);

     m_sm.setExitAction(INACTIVE, &ActiveObject::inactiveExit); 
       : 
     m_sm.setPostDoAction(ERROR, &ActiveObject::errorPostDo); 
     m_sm.setTransitionAction(&ActiveObject:transition); 
   };

   bool nullAction(MyStates st) {}; 
   bool inactiveExit(MyStates st) {}; 
     : 
   bool errorPostDo(MyStates st) {}; 
   bool transition(MyStates st) {};

 private: 
   StateMachine<MyState, bool, ActiveObject> m_sm; 
 }; 
 

If you want to give a class to some states, you must implement the class to satisfy the following conditions:

1. You must define states by enum.
2. Template arguments of StateMachine must be <type of state(MyState), listener object, state holder，callback function>
3. Constructor arguments of StateMachine must be the number of the states.
4. You must set the following action functions as a function of (Return _function_name_(States))
   1. You must define a function that does not do anything and give with setNOP.
   2. You must set actions to each state by set(Entry|PreDo|Do|PostDo|Exit)Action.
   3. You should set actions at the state transition by setTransitionAction().
5. You must implement action at the transition based on given states, such as current state, next state and previous state.
6. You should change states by goTo() and check the state by isIn(state).
7. goTo() is a function that sets next state forcibly, therefore, to determine the next state, you must get current state and implement that logic.

In this class, you can define the following five actions for one state:

• Entry action
• PreDo action
• Do action
• PostDo action
• Exit action

Transition action is an action invoked at the transition between any states, and you must define its behavior.

This class executes each action according to the following timing.

• If the state is changed and transits(A->B) state,
  (A:Exit)->|(state update:A->B)->(B:Entry)->(B:PreDo)->(B:Do)->(B:PostDo)

• If the state is not changed and remains B state, (| shows a step's break) (B(n-1):PostDo)->|(B(n):PreDo)->(B(n):Do)->(B(n):PostDo)->|(B(n+1):PreDo) PreDo, Do and PostDo are executed over and over again.

• If the state transits to itself
  (B(n-1):PostDo)->(B(n-1):Exit)->|(B(n):Entry)->(B(n):PreDo)
  Once Exit is invoked, Entry is executed, and then the same operation described above will be done from here on.

Parameters:

	State	Type of the state
	Listener	Listener object for action
	States	State holder
	Callback	Callback function for action

Since:

0.4.0

---

Constructor & Destructor Documentation

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

RTC_Utils::StateMachine< State, Listener, States, Callback >::StateMachine

(

int

num_of_state

)

[inline]

Constructor.

Constructor

Parameters:

num_of_state

Number of states in the state machine

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

virtual RTC_Utils::StateMachine< State, Listener, States, Callback >::~StateMachine

(

)

[inline, virtual]

---

Member Function Documentation

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

State RTC_Utils::StateMachine< State, Listener, States, Callback >::getState

(

)

[inline]

Get current state.

Get current state.

Returns:

Current state

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

States RTC_Utils::StateMachine< State, Listener, States, Callback >::getStates

(

)

[inline]

Get states.

Get state information. Get the current state, the previous state and the next state to be expected to transfer.

Returns:

State information

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

void RTC_Utils::StateMachine< State, Listener, States, Callback >::goTo

(

State

state

)

[inline]

Transit State.

Transit to the specified state. This function sets the next state forcibly. Therefore, to determine the next state, users must get current state and implement that logic. If transit destination is the same as the current state, flag of self-transition will be set.

Parameters:

state

State of the transition destination

Referenced by RTC::PeriodicExecutionContext::DFP< OpenRTM::DataFlowComponent_var >::on_activated(), RTC::PeriodicExecutionContext::DFP< OpenRTM::DataFlowComponent_var >::on_execute(), RTC::PeriodicExecutionContext::DFP< OpenRTM::DataFlowComponent_var >::on_reset(), and RTC::PeriodicExecutionContext::DFP< OpenRTM::DataFlowComponent_var >::on_state_update().

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

bool RTC_Utils::StateMachine< State, Listener, States, Callback >::isIn

(

State

state

)

[inline]

Check current state.

Check whether current state matches the state specified by argument.

Parameters:

state

Target state for the check

Returns:

Check state result

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

bool RTC_Utils::StateMachine< State, Listener, States, Callback >::setDoAction	(	State	state,
		Callback	call_back
	)			[inline]

Set Do action function.

Set callback function for Do action that is executed in each state.

Parameters:

	state	Target state for the set
	call_back	Callback function for Do action

Returns:

Action execution result

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

bool RTC_Utils::StateMachine< State, Listener, States, Callback >::setEntryAction	(	State	state,
		Callback	call_back
	)			[inline]

Set Entry action function.

Set callback function for Entry action that is executed when entering in each state.

Parameters:

	state	Target state for the set
	call_back	Callback function for Entry action

Returns:

Action execution result

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

bool RTC_Utils::StateMachine< State, Listener, States, Callback >::setExitAction	(	State	state,
		Callback	call_back
	)			[inline]

Set Exit action function.

Set callback function for Exit action that is executed in each state.

Parameters:

	state	Target state for the set
	call_back	Callback function for Exit action

Returns:

Action execution result

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

void RTC_Utils::StateMachine< State, Listener, States, Callback >::setListener

(

Listener *

listener

)

[inline]

Set Listener Object.

Set Listener Object invoked when various actions are executed.

Parameters:

listener

Listener object

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

void RTC_Utils::StateMachine< State, Listener, States, Callback >::setNOP

(

Callback

call_back

)

[inline]

Set NOP function.

Set NOP function that does not do anything

Parameters:

call_back

Callback function

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

void RTC_Utils::StateMachine< State, Listener, States, Callback >::setNullFunc	(	Callback *	s,
		Callback	nullfunc
	)			[inline, protected]

Set NOP function.

Set NOP function (function to do nothing).

Parameters:

	s	Callback function for setting
	nullfunc	Callback function (NOP function)

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

bool RTC_Utils::StateMachine< State, Listener, States, Callback >::setPostDoAction	(	State	state,
		Callback	call_back
	)			[inline]

Set PostDo action function.

Set callback function for PostDo action that is executed in each state.

Parameters:

	state	Target state for the set
	call_back	Callback function for PostDo action

Returns:

Action execution result

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

bool RTC_Utils::StateMachine< State, Listener, States, Callback >::setPreDoAction	(	State	state,
		Callback	call_back
	)			[inline]

Set PreDo action function.

Set callback function for PreDo action that is executed in each state.

Parameters:

	state	Target state for the set
	call_back	Callback function for PreDo action

Returns:

Action execution result

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

void RTC_Utils::StateMachine< State, Listener, States, Callback >::setStartState

(

States

states

)

[inline]

Set the initial state.

Set the initial state of the state machine.

Parameters:

states

Initial state

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

bool RTC_Utils::StateMachine< State, Listener, States, Callback >::setTransitionAction

(

Callback

call_back

)

[inline]

Set state transition action function.

Set callback function for State transition action that is executed when transiting to the state.

Parameters:

call_back

Callback function for State transition

Returns:

Action execution result

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

void RTC_Utils::StateMachine< State, Listener, States, Callback >::worker

(

)

[inline]

Worker function.

This is a worker function of the state machine. Execute the invocation of each action at actual state transition and the state transition occurrence.

---

Member Data Documentation

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

Callback* RTC_Utils::StateMachine< State, Listener, States, Callback >::m_do [protected]

Callback function for Do action.

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

Callback* RTC_Utils::StateMachine< State, Listener, States, Callback >::m_entry [protected]

Callback function for Entry action.

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

Callback* RTC_Utils::StateMachine< State, Listener, States, Callback >::m_exit [protected]

Callback function for Exit action.

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

Listener* RTC_Utils::StateMachine< State, Listener, States, Callback >::m_listener [protected]

Callback function for listener.

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

Mutex RTC_Utils::StateMachine< State, Listener, States, Callback >::m_mutex [protected]

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

int RTC_Utils::StateMachine< State, Listener, States, Callback >::m_num [protected]

Number of state.

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

Callback* RTC_Utils::StateMachine< State, Listener, States, Callback >::m_postdo [protected]

Callback function for PostDo action.

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

Callback* RTC_Utils::StateMachine< State, Listener, States, Callback >::m_predo [protected]

Callback function for PreDo action.

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

bool RTC_Utils::StateMachine< State, Listener, States, Callback >::m_selftrans [protected]

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

States RTC_Utils::StateMachine< State, Listener, States, Callback >::m_states [protected]

Current state information.

template<class State, class Listener, class States = StateHolder<State>, class Callback = void (Listener::*)(const States& states)>

Callback RTC_Utils::StateMachine< State, Listener, States, Callback >::m_transit [protected]

Callback function for State transition action.