State machine class. More...

#include <StateMachine.h>

Collaboration diagram for RTC_Utils::StateMachine< State, Listener, States, Callback >:

Public Member Functions
	StateMachine (int num_of_state)
	Constructor.
virtual	~StateMachine ()
	StateMachine (const StateMachine &other)
StateMachine &	operator= (const StateMachine &other)
void	swap (StateMachine &other)
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.
void	worker_pre ()
void	worker_do ()
void	worker_post ()

Protected Member Functions
void	setNullFunc (std::vector< Callback > &s, Callback nullfunc)
	Set NOP function.

Protected Attributes
int	m_num
	Number of state .
Listener *	m_listener
	Callback function for listener .
std::vector< Callback >	m_entry
	Callback function for Entry action .
std::vector< Callback >	m_predo
	Callback function for PreDo action .
std::vector< Callback >	m_do
	Callback function for Do action .
std::vector< Callback >	m_postdo
	Callback function for PostDo action .
std::vector< 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
std::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 };
  using MyStates = States<MyState>;

  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:

You must define states by enum.
Template arguments of StateMachine must be <type of state(MyState), listener object, state holder，callback function>
Constructor arguments of StateMachine must be the number of the states.
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().
You must implement action at the transition based on given states, such as current state, next state and previous state.
You should change states by goTo() and check the state by isIn(state).
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

◆ StateMachine() [1/2]

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 )

inlineexplicit

Constructor.

Constructor

Parameters

num_of_state Number of states in the state machine

References m_do, m_entry, m_exit, m_listener, m_num, m_postdo, m_predo, m_selftrans, and m_transit.

Referenced by operator=(), StateMachine(), and swap().

◆ ~StateMachine()

template<class T, class U, class V, class W>

RTC_Utils::StateMachine< T, U, V, W >::~StateMachine ( )

virtualdefault

◆ StateMachine() [2/2]

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

RTC_Utils::StateMachine< State, Listener, States, Callback >::StateMachine ( const StateMachine< State, Listener, States, Callback > & other )

inline

References m_do, m_entry, m_exit, m_listener, m_num, m_postdo, m_predo, m_selftrans, m_states, m_transit, and StateMachine().

Member Function Documentation

◆ getState()

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.

Returns: Current state

References m_mutex, and m_states.

◆ getStates()

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

References m_mutex, and m_states.

◆ goTo()

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

References m_mutex, m_selftrans, and m_states.

◆ isIn()

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

References m_mutex, and m_states.

◆ operator=()

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

StateMachine & RTC_Utils::StateMachine< State, Listener, States, Callback >::operator= ( const StateMachine< State, Listener, States, Callback > & other )

inline

References StateMachine(), and swap().

◆ setDoAction()

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

References m_do.

◆ setEntryAction()

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

References m_entry.

◆ setExitAction()

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

References m_exit.

◆ setListener()

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

References m_listener.

◆ setNOP()

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

References m_do, m_entry, m_exit, m_postdo, m_predo, m_transit, and setNullFunc().

◆ setNullFunc()

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	(	std::vector< Callback > &	s,
		Callback	nullfunc )

inlineprotected

Set NOP function.

Set NOP function (function to do nothing).

Parameters

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

References m_num.

Referenced by setNOP().

◆ setPostDoAction()

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

References m_postdo.

◆ setPreDoAction()

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

References m_predo.

◆ setStartState()

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

References m_states.

◆ setTransitionAction()

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

References m_transit.

◆ swap()

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

void RTC_Utils::StateMachine< State, Listener, States, Callback >::swap ( StateMachine< State, Listener, States, Callback > & other )

inline

References m_do, m_entry, m_exit, m_listener, m_num, m_postdo, m_predo, m_selftrans, m_states, m_transit, and StateMachine().

Referenced by operator=().

◆ worker()

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.

References m_do, m_entry, m_exit, m_listener, m_postdo, and m_predo.

◆ worker_do()

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_do ( )

inline

References m_do, and m_listener.

◆ worker_post()

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_post ( )

inline

References m_listener, and m_postdo.

◆ worker_pre()

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_pre ( )

inline

References m_entry, m_exit, m_listener, and m_predo.

Member Data Documentation

◆ m_do

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

std::vector<Callback> RTC_Utils::StateMachine< State, Listener, States, Callback >::m_do

protected

Callback function for Do action .

Referenced by setDoAction(), setNOP(), StateMachine(), StateMachine(), swap(), worker(), and worker_do().

◆ m_entry

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

std::vector<Callback> RTC_Utils::StateMachine< State, Listener, States, Callback >::m_entry

protected

Callback function for Entry action .

Referenced by setEntryAction(), setNOP(), StateMachine(), StateMachine(), swap(), worker(), and worker_pre().

◆ m_exit

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

std::vector<Callback> RTC_Utils::StateMachine< State, Listener, States, Callback >::m_exit

protected

Callback function for Exit action .

Referenced by setExitAction(), setNOP(), StateMachine(), StateMachine(), swap(), worker(), and worker_pre().

◆ m_listener

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 .

Referenced by setListener(), StateMachine(), StateMachine(), swap(), worker(), worker_do(), worker_post(), and worker_pre().

◆ m_mutex

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

std::mutex RTC_Utils::StateMachine< State, Listener, States, Callback >::m_mutex

protected

Referenced by getState(), getStates(), goTo(), and isIn().

◆ m_num

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 .

Referenced by setNullFunc(), StateMachine(), StateMachine(), and swap().

◆ m_postdo

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

std::vector<Callback> RTC_Utils::StateMachine< State, Listener, States, Callback >::m_postdo

protected

Callback function for PostDo action .

Referenced by setNOP(), setPostDoAction(), StateMachine(), StateMachine(), swap(), worker(), and worker_post().

◆ m_predo

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

std::vector<Callback> RTC_Utils::StateMachine< State, Listener, States, Callback >::m_predo

protected

Callback function for PreDo action .

Referenced by setNOP(), setPreDoAction(), StateMachine(), StateMachine(), swap(), worker(), and worker_pre().

◆ m_selftrans

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

Referenced by goTo(), StateMachine(), StateMachine(), and swap().

◆ m_states

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 .

Referenced by getState(), getStates(), goTo(), isIn(), setStartState(), StateMachine(), and swap().

◆ m_transit

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 .

Referenced by setNOP(), setTransitionAction(), StateMachine(), StateMachine(), and swap().

The documentation for this class was generated from the following file:

StateMachine.h

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ StateMachine() [1/2]

◆ ~StateMachine()

◆ StateMachine() [2/2]

Member Function Documentation

◆ getState()

◆ getStates()

◆ goTo()

◆ isIn()

◆ operator=()

◆ setDoAction()

◆ setEntryAction()

◆ setExitAction()

◆ setListener()

◆ setNOP()

◆ setNullFunc()

◆ setPostDoAction()

◆ setPreDoAction()

◆ setStartState()

◆ setTransitionAction()

◆ swap()

◆ worker()

◆ worker_do()

◆ worker_post()

◆ worker_pre()

Member Data Documentation

◆ m_do

◆ m_entry

◆ m_exit

◆ m_listener

◆ m_mutex

◆ m_num

◆ m_postdo

◆ m_predo

◆ m_selftrans

◆ m_states

◆ m_transit