A hierarchical StateMachine which is loaded in the Program Processor. More...

#include <StateMachine.hpp>

Inheritance diagram for RTT::scripting::StateMachine:

Classes
struct	Status
Public Types
typedef std::vector < StateMachinePtr >	ChildList
Public Member Functions
bool	activate ()
void	addChild (StateMachinePtr child)
void	addState (StateInterface *s)
bool	automatic ()
bool	createEventTransition (ServicePtr sp, const std::string &ename, std::vector< base::DataSourceBase::shared_ptr > args, StateInterface from, StateInterface to, ConditionInterface guard, boost::shared_ptr< ProgramInterface > transprog, StateInterface elseto=0, boost::shared_ptr< ProgramInterface > elseprog=boost::shared_ptr< ProgramInterface >())
ProgramInterface *	currentProgram () const
StateInterface *	currentState () const
bool	deactivate ()
bool	execute ()
bool	executePending (bool stepping=false)
const ChildList &	getChildren () const
const std::string &	getCurrentStateName () const
StateInterface *	getFinalState () const
base::ActionInterface *	getInitCommand () const
StateInterface *	getInitialState () const
int	getLineNumber () const
const std::string &	getName () const
StateMachinePtr	getParent () const
StateInterface *	getState (const std::string &name) const
std::vector< std::string >	getStateList () const
Status::StateMachineStatus	getStatus () const
std::string	getStatusStr () const
virtual std::string	getText () const
bool	inError () const
bool	inFinalState () const
bool	inInitialState () const
bool	inState (const std::string &state) const
bool	inStrictState (const std::string &state) const
bool	interruptible () const
bool	inTransition () const
bool	isActive () const
bool	isAutomatic () const
bool	isPaused () const
bool	isReactive () const
bool	isStopped () const
bool	isStrictlyActive () const
void	loading ()
StateInterface *	nextState ()
bool	pause ()
void	preconditionSet (StateInterface state, ConditionInterface cnd, int line)
bool	reactive ()
bool	requestFinalState ()
bool	requestInitialState ()
StateInterface *	requestNextState (bool stepping=false)
StateInterface *	requestNextStateStep ()
bool	requestState (const std::string &statename)
bool	requestStateChange (StateInterface *s_n)
bool	reset ()
void	setFinalState (StateInterface *s)
void	setInitCommand (base::ActionInterface *c)
void	setInitialState (StateInterface *s)
void	setParent (StateMachinePtr parent)
bool	start ()
	StateMachine (StateMachinePtr parent, const std::string &name="Default")
bool	step ()
bool	stepDone () const
bool	stop ()
void	trace (bool on_off)
void	transitionSet (StateInterface from, StateInterface to, ConditionInterface *cnd, int priority, int line)
void	transitionSet (StateInterface from, StateInterface to, ConditionInterface *cnd, boost::shared_ptr< ProgramInterface > transprog, int priority, int line)
void	unloading ()
virtual	~StateMachine ()
Protected Types
typedef std::vector < boost::tuple< ServicePtr, std::string, std::vector < base::DataSourceBase::shared_ptr > , StateInterface , ConditionInterface , boost::shared_ptr < ProgramInterface >, Handle, StateInterface *, boost::shared_ptr < ProgramInterface > > >	EventList
typedef std::map < StateInterface *, EventList >	EventMap
typedef std::multimap < StateInterface , std::pair < ConditionInterface , int > >	PreConditionMap
typedef boost::weak_ptr < StateMachine >	StateMachineParentPtr
typedef std::map < StateInterface *, TransList >	TransitionMap
typedef std::vector < boost::tuple < ConditionInterface , StateInterface , int, int, boost::shared_ptr < ProgramInterface > > >	TransList
Protected Member Functions
void	changeState (StateInterface s, ProgramInterface tprog, bool stepping=false)
int	checkConditions (StateInterface *state, bool stepping=false)
void	disableEvents (StateInterface *s)
void	disableGlobalEvents ()
void	enableEvents (StateInterface *s)
void	enableGlobalEvents ()
void	enterState (StateInterface *s)
bool	executeProgram (ProgramInterface *&cp, bool stepping)
void	handleState (StateInterface *s)
void	leaveState (StateInterface *s)
void	runState (StateInterface *s)
Protected Attributes
std::vector< StateMachinePtr >	_children
std::string	_name
StateMachineParentPtr	_parent
EventMap	eventMap
PreConditionMap	precondMap
Status::StateMachineStatus	smStatus
TransitionMap	stateMap
Private Types
enum	PrivateStatus { nill, gostop, goreset, pausing }
Private Member Functions
bool	eventTransition (StateInterface from, ConditionInterface c, ProgramInterface p, StateInterface to, ProgramInterface elsep, StateInterface elseto)
Private Attributes
bool	checking_precond
StateInterface *	current
ProgramInterface *	currentEntry
ProgramInterface *	currentExit
ProgramInterface *	currentHandle
ProgramInterface *	currentProg
ProgramInterface *	currentRun
ProgramInterface *	currentTrans
int	evaluating
os::MutexRecursive	execlock
StateInterface *	finistate
base::ActionInterface *	initc
StateInterface *	initstate
bool	mstep
bool	mtrace
StateInterface *	next
std::pair < PreConditionMap::const_iterator, PreConditionMap::const_iterator >	prec_it
TransList::iterator	reqend
TransList::iterator	reqstep
enum RTT::scripting::StateMachine::PrivateStatus	smpStatus
Static Private Attributes
static std::string	emptyString

Detailed Description

A hierarchical StateMachine which is loaded in the Program Processor.

A StateMachine can have children and one parent.

Todo:: Implement the whole transition mechanism with the Strategy software pattern to allow cleaner implementation.

Definition at line 72 of file StateMachine.hpp.

Member Typedef Documentation

typedef std::vector<StateMachinePtr> RTT::scripting::StateMachine::ChildList

Definition at line 109 of file StateMachine.hpp.

typedef std::vector< boost::tuple<ServicePtr, std::string, std::vector<base::DataSourceBase::shared_ptr>, StateInterface*, ConditionInterface*, boost::shared_ptr<ProgramInterface>, Handle, StateInterface*, boost::shared_ptr<ProgramInterface> > > RTT::scripting::StateMachine::EventList [protected]

Definition at line 98 of file StateMachine.hpp.

typedef std::map< StateInterface*, EventList > RTT::scripting::StateMachine::EventMap [protected]

Definition at line 99 of file StateMachine.hpp.

typedef std::multimap< StateInterface*, std::pair<ConditionInterface*, int> > RTT::scripting::StateMachine::PreConditionMap [protected]

Definition at line 92 of file StateMachine.hpp.

typedef boost::weak_ptr<StateMachine> RTT::scripting::StateMachine::StateMachineParentPtr [protected]

Definition at line 101 of file StateMachine.hpp.

typedef std::map< StateInterface*, TransList > RTT::scripting::StateMachine::TransitionMap [protected]

Definition at line 91 of file StateMachine.hpp.

typedef std::vector< boost::tuple<ConditionInterface*, StateInterface*, int, int, boost::shared_ptr<ProgramInterface> > > RTT::scripting::StateMachine::TransList [protected]

The key is the current state, the value is the transition condition to another state with a certain priority (int), on a line (int), with a transition program

Definition at line 90 of file StateMachine.hpp.

Member Enumeration Documentation

enum RTT::scripting::StateMachine::PrivateStatus [private]

Enumerator:

nill
gostop
goreset
pausing

Definition at line 75 of file StateMachine.hpp.

Constructor & Destructor Documentation

RTT::StateMachine::~StateMachine ( ) [virtual]

The destructor is virtual since ParsedStateMachine still inherits this class.

Definition at line 71 of file StateMachine.cpp.

RTT::StateMachine::StateMachine	(	StateMachinePtr	parent,
		const std::string &	name = `"Default"`
	)

Create a new StateMachine with an optional parent. Set parent to zero for the top state machine. The initial Status of a StateMachine is always inactive.

Definition at line 62 of file StateMachine.cpp.

Member Function Documentation

bool RTT::StateMachine::activate ( )

Start this StateMachine. The Initial state will be entered.

Definition at line 1147 of file StateMachine.cpp.

void RTT::scripting::StateMachine::addChild ( StateMachinePtr child ) [inline]

Definition at line 562 of file StateMachine.hpp.

void RTT::StateMachine::addState ( StateInterface * s )

Add a State. If already present, changes nothing.

Definition at line 762 of file StateMachine.cpp.

bool RTT::StateMachine::automatic ( )

Enter automatic mode: evaluating the transition conditions continuously.

Definition at line 209 of file StateMachine.cpp.

void RTT::StateMachine::changeState	(	StateInterface *	s,
		ProgramInterface *	tprog,
		bool	stepping = `false`
	)		`[protected]`

Definition at line 408 of file StateMachine.cpp.

int RTT::StateMachine::checkConditions	(	StateInterface *	state,
		bool	stepping = `false`
	)		`[protected]`

Definition at line 693 of file StateMachine.cpp.

bool RTT::StateMachine::createEventTransition	(	ServicePtr	sp,
		const std::string &	ename,
		std::vector< base::DataSourceBase::shared_ptr >	args,
		StateInterface *	from,
		StateInterface *	to,
		ConditionInterface *	guard,
		boost::shared_ptr< ProgramInterface >	transprog,
		StateInterface *	elseto = `0`,
		boost::shared_ptr< ProgramInterface >	elseprog = `boost::shared_ptr<ProgramInterface>()`
	)

Express a possible transition from one state to another when an Event is fired under a certain condition (guard).

Parameters:

ename	The name of the Event under which a transition should be made
args	The arguments which the event handler must set upon occurence.
from	The state which should be left
to	The state which should be entered
guard	The Condition under which the transition may succeed
transprog	The program to be executed between exit of from and entry of to.
sp	The Service in which ename can be found.

Definition at line 507 of file StateMachine.cpp.

ProgramInterface * RTT::StateMachine::currentProgram ( ) const

Retrieve the current program in execution. Returns null if the StateMachine is not active or no programs are being run.

Definition at line 910 of file StateMachine.cpp.

StateInterface * RTT::StateMachine::currentState ( ) const

Retrieve the current state of the state machine. Returns null if the StateMachine is not active.

Definition at line 905 of file StateMachine.cpp.

bool RTT::StateMachine::deactivate ( )

Stop this StateMachine. The current state is left unconditionally.

Definition at line 1197 of file StateMachine.cpp.

void RTT::StateMachine::disableEvents ( StateInterface * s ) [protected]

Definition at line 491 of file StateMachine.cpp.

void RTT::StateMachine::disableGlobalEvents ( ) [protected]

Definition at line 473 of file StateMachine.cpp.

void RTT::StateMachine::enableEvents ( StateInterface * s ) [protected]

Definition at line 477 of file StateMachine.cpp.

void RTT::StateMachine::enableGlobalEvents ( ) [protected]

Definition at line 469 of file StateMachine.cpp.

void RTT::StateMachine::enterState ( StateInterface * s ) [protected]

Definition at line 959 of file StateMachine.cpp.

bool RTT::StateMachine::eventTransition	(	StateInterface *	from,
		ConditionInterface *	c,
		ProgramInterface *	p,
		StateInterface *	to,
		ProgramInterface *	elsep,
		StateInterface *	elseto
	)		`[private]`

Internal use only. Make a transition to state 'to' with transitionprogram 'p' under condition 'c'. if from != current or in transition already, discard transition.

Definition at line 563 of file StateMachine.cpp.

bool RTT::StateMachine::execute ( ) [virtual]

Used by the StateMachineProcessor to execute the next action(s) or state transitions.

Implements RTT::base::ExecutableInterface.

Definition at line 262 of file StateMachine.cpp.

bool RTT::StateMachine::executePending ( bool stepping = false )

Execute any pending State (exit, entry, handle) programs. You must executePending, before calling requestState() or requestNextState(). You should only call requestState() or requestNextState() if executePending returns true.

Due to the pending requests, the currentState() may have changed.

Parameters:

stepping provide true if the pending programs should be executed one step at a time.

Return values:

true	if nothing was pending
false	if there was some program executing.

Definition at line 983 of file StateMachine.cpp.

bool RTT::StateMachine::executeProgram	(	ProgramInterface *&	cp,
		bool	stepping
	)		`[protected]`

Definition at line 1095 of file StateMachine.cpp.

const ChildList& RTT::scripting::StateMachine::getChildren ( ) const [inline]

Get a list of all child state machines.

Definition at line 557 of file StateMachine.hpp.

const std::string& RTT::scripting::StateMachine::getCurrentStateName ( ) const [inline]

Return name of current state, empty string if not active.

Definition at line 164 of file StateMachine.hpp.

StateInterface* RTT::scripting::StateMachine::getFinalState ( ) const [inline]

Retrieve the final state of the state machine.

Definition at line 520 of file StateMachine.hpp.

base::ActionInterface* RTT::scripting::StateMachine::getInitCommand ( ) const [inline]

Definition at line 536 of file StateMachine.hpp.

StateInterface* RTT::scripting::StateMachine::getInitialState ( ) const [inline]

Retrieve the initial state of the state machine.

Definition at line 513 of file StateMachine.hpp.

int RTT::StateMachine::getLineNumber ( ) const

Returns the current program line in execution,

Returns:: 1 if not active

Definition at line 848 of file StateMachine.cpp.

const std::string& RTT::scripting::StateMachine::getName ( ) const [inline]

This method must be overloaded to get a useful hierarchy.

Definition at line 570 of file StateMachine.hpp.

StateMachinePtr RTT::scripting::StateMachine::getParent ( ) const [inline]

Get the parent, returns zero if no parent.

Definition at line 544 of file StateMachine.hpp.

StateInterface * RTT::StateMachine::getState ( const std::string & name ) const

Lookup a State by name. Returns null if not found.

Definition at line 768 of file StateMachine.cpp.

std::vector< std::string > RTT::StateMachine::getStateList ( ) const

Get a list of the names of all the present states.

Definition at line 752 of file StateMachine.cpp.

StateMachine::Status::StateMachineStatus RTT::StateMachine::getStatus ( ) const

Get the status of this state machine.

Definition at line 123 of file StateMachine.cpp.

string RTT::StateMachine::getStatusStr ( ) const

Get the status in a readable string format.

Definition at line 127 of file StateMachine.cpp.

string RTT::StateMachine::getText ( ) const [virtual]

Return the text to which getLineNumber() refers.

Reimplemented in RTT::scripting::ParsedStateMachine.

Definition at line 865 of file StateMachine.cpp.

void RTT::StateMachine::handleState ( StateInterface * s ) [protected]

Definition at line 946 of file StateMachine.cpp.

bool RTT::scripting::StateMachine::inError ( ) const [inline]

Get the error status of this StateMachine.

Definition at line 216 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::inFinalState ( ) const [inline]

Inspect if we are in the final state.

Definition at line 188 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::inInitialState ( ) const [inline]

Inspect if we are in the initial state.

Definition at line 181 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::inState ( const std::string & state ) const [inline]

Check if the state machine is in a given state.

Definition at line 143 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::inStrictState ( const std::string & state ) const [inline]

Check if the state machine is in a given state and not in the entry or exit program.

Definition at line 154 of file StateMachine.hpp.

bool RTT::StateMachine::interruptible ( ) const

Inspect if the StateMachine is interruptible by events. Only the run program may be interrupted, or if no program is currently executed.

Definition at line 1127 of file StateMachine.cpp.

bool RTT::StateMachine::inTransition ( ) const

Inspect if the StateMachine is performing a state transition. A transition is in progress if entry, transition or exit programs are executed.

Returns:: true if it is executing a program (except run or handle program), false if it is not executing a program OR executing the run/handle program.

Definition at line 1122 of file StateMachine.cpp.

bool RTT::scripting::StateMachine::isActive ( ) const [inline]

Returns true if the state machine is activated.

Definition at line 205 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::isAutomatic ( ) const [inline]

Query if the state machine is reacting to events and evaluating transition conditions.

Definition at line 227 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::isPaused ( ) const [inline]

Query if the state machine is paused.

Definition at line 232 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::isReactive ( ) const [inline]

Query if the state machine is currently reacting only to events.

Definition at line 221 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::isStopped ( ) const [inline]

Returns true if the state machine is in the final state, after a stop() directive.

Definition at line 211 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::isStrictlyActive ( ) const [inline]

Strictly active, means active and not in a transition.

Definition at line 174 of file StateMachine.hpp.

void RTT::StateMachine::leaveState ( StateInterface * s ) [protected]

Definition at line 915 of file StateMachine.cpp.

void RTT::StateMachine::loading ( ) [virtual]

Informs this object that it got loaded in an ExecutionEngine. Called by load() after the engine pointer is set.

Reimplemented from RTT::base::ExecutableInterface.

Definition at line 81 of file StateMachine.cpp.

StateInterface * RTT::StateMachine::nextState ( )

Search from the current state a candidate next state. If none is found, the current state is returned.

Note:: The mere calling of this method, may influence future possible results. Multiple invocations of nextState() may return different results, so use with care.

See also:: requestNextState()

Definition at line 726 of file StateMachine.cpp.

bool RTT::StateMachine::pause ( )

Pause the state machine.

Definition at line 171 of file StateMachine.cpp.

void RTT::StateMachine::preconditionSet	(	StateInterface *	state,
		ConditionInterface *	cnd,
		int	line
	)

Express a precondition for entering a state. The precondition will be chained (Logical AND) with any transition to this state. This means that any transition to this state will only succeed if all preconditions hold. If state is the initial state, the preconditions must be true to make actiate() succeed. If state is the final state, they will not be checked upon requestFinalState, since requestFinalState always succeeds.

Parameters:

state	The state for which the preconditions must hold
cnd	The Pre-Condition under which a transition to this state may succeed
line	The line number where this precondition was introduced.

Definition at line 869 of file StateMachine.cpp.

bool RTT::StateMachine::reactive ( )

Switch to reactive mode from automatic mode.

Definition at line 225 of file StateMachine.cpp.

bool RTT::StateMachine::requestFinalState ( )

Request going to the Final State. This will always proceed.

Definition at line 390 of file StateMachine.cpp.

bool RTT::StateMachine::requestInitialState ( )

Request going to the Initial State. This function will only proceed if the current state is the Final State or the Initial State. If it fails, one can try to requestNextState() which may lead to the initial state anyway if the transition is set. This path is not tried by this function.

Returns:: The true on success, false if not allowed.

Definition at line 375 of file StateMachine.cpp.

StateInterface * RTT::StateMachine::requestNextState ( bool stepping = false )

Search from the current state a candidate next state. If none is found, the current state is taken. Next, handle the resulting state.

Note:: This call is not equivalent to this->requestState( this->nextState() ), since multiple invocations of this->nextState() may result in different results, hence, this->requestState( this->nextState() ) may return false. Use this method instead to automatically go to the next state.

Parameters:

stepping provide true if the transition evaluations should be executed one at a time.

Returns:: The current state.

Definition at line 610 of file StateMachine.cpp.

StateInterface* RTT::scripting::StateMachine::requestNextStateStep ( )

Go stepwise through evaluations to find out next state.

See also:: requestNextState()

bool RTT::scripting::StateMachine::requestState ( const std::string & statename ) [inline]

Request a transition to a given state.

Definition at line 132 of file StateMachine.hpp.

bool RTT::StateMachine::requestStateChange ( StateInterface * s_n )

Request a state transition to a new state. If the transition is not set by transitionSet(), acquiering the state will fail.

Parameters:

s_n	The state to change to

Return values:

true	if the transition is successfull
false	if the transition is not allowed

Definition at line 779 of file StateMachine.cpp.

bool RTT::StateMachine::reset ( void )

Reset the state machine from the final state to the initial state and wait for events or requests.

Definition at line 249 of file StateMachine.cpp.

void RTT::StateMachine::runState ( StateInterface * s ) [protected]

Definition at line 932 of file StateMachine.cpp.

void RTT::StateMachine::setFinalState ( StateInterface * s )

Set the final state of this StateMachine.

Definition at line 1137 of file StateMachine.cpp.

void RTT::scripting::StateMachine::setInitCommand ( base::ActionInterface * c ) [inline]

This was added for extra (non-user visible) initialisation when the StateMachine is activated.

Parameters:

c	The command to execute upon each activate. c is aggregated by this state machine and deleted in the destructor.

Definition at line 531 of file StateMachine.hpp.

void RTT::StateMachine::setInitialState ( StateInterface * s )

Set the initial state of this StateMachine.

Definition at line 1131 of file StateMachine.cpp.

void RTT::scripting::StateMachine::setParent ( StateMachinePtr parent ) [inline]

Definition at line 549 of file StateMachine.hpp.

bool RTT::StateMachine::start ( void )

Enter automatic mode: evaluating the transition conditions continuously.

Definition at line 204 of file StateMachine.cpp.

bool RTT::StateMachine::step ( )

Execute a single action if the state machine is paused or evaluate the transition conditions if the state machine is reactive.

Definition at line 187 of file StateMachine.cpp.

bool RTT::scripting::StateMachine::stepDone ( ) const [inline]

When isPaused(), return true if no step is pending, when isReactive(), return isStrictlyActive()

Definition at line 196 of file StateMachine.hpp.

bool RTT::StateMachine::stop ( void )

Bring the state machine to the safe final state and wait for events or requests.

Definition at line 237 of file StateMachine.cpp.

void RTT::StateMachine::trace ( bool on_off )

Turn log(Debug) messages on or off to track state transitions.

Definition at line 1143 of file StateMachine.cpp.

void RTT::StateMachine::transitionSet	(	StateInterface *	from,
		StateInterface *	to,
		ConditionInterface *	cnd,
		int	priority,
		int	line
	)

Express a possible transition from one state to another under a certain condition.

Parameters:

from	The state which should be left
to	The state which should be entered
cnd	The Condition under which the transition may succeed
priority	The priority of this transition; low number (like -1000) is low priority high number is high priority (like + 1000). Transitions of equal priority are traversed in an unspecified way.
line	The line number where this transition was introduced.

Postcondition:: All transitions from from to to will succeed under condition cnd

Definition at line 878 of file StateMachine.cpp.

void RTT::StateMachine::transitionSet	(	StateInterface *	from,
		StateInterface *	to,
		ConditionInterface *	cnd,
		boost::shared_ptr< ProgramInterface >	transprog,
		int	priority,
		int	line
	)

Express a possible transition from one state to another under a certain condition.

Parameters:

from	The state which should be left
to	The state which should be entered
cnd	The Condition under which the transition may succeed
transprog	The program to be executed between exit of from and entry of to. May be null to indicate the empty program.
priority	The priority of this transition; low number (like -1000) is low priority high number is high priority (like + 1000). Transitions of equal priority are traversed in an unspecified way.
line	The line number where this transition was introduced.

Postcondition:: All transitions from from to to will succeed under condition cnd

Definition at line 883 of file StateMachine.cpp.

void RTT::StateMachine::unloading ( ) [virtual]

Informs this object that it got unloaded from an ExecutionEngine. Called by unload() before the engine pointer is cleared.

Reimplemented from RTT::base::ExecutableInterface.

Reimplemented in RTT::scripting::ParsedStateMachine.

Definition at line 105 of file StateMachine.cpp.

Member Data Documentation

std::vector<StateMachinePtr> RTT::scripting::StateMachine::_children [protected]

Definition at line 100 of file StateMachine.hpp.

std::string RTT::scripting::StateMachine::_name [protected]

Definition at line 104 of file StateMachine.hpp.

StateMachineParentPtr RTT::scripting::StateMachine::_parent [protected]

Definition at line 102 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::checking_precond [private]

Definition at line 682 of file StateMachine.hpp.

StateInterface* RTT::scripting::StateMachine::current [private]

The current state the Machine is in. current == 0 means that the state machine is currently inactive.

Definition at line 662 of file StateMachine.hpp.

ProgramInterface* RTT::scripting::StateMachine::currentEntry [private]

Definition at line 674 of file StateMachine.hpp.

ProgramInterface* RTT::scripting::StateMachine::currentExit [private]

Definition at line 672 of file StateMachine.hpp.

ProgramInterface* RTT::scripting::StateMachine::currentHandle [private]

Definition at line 673 of file StateMachine.hpp.

ProgramInterface* RTT::scripting::StateMachine::currentProg [private]

Definition at line 671 of file StateMachine.hpp.

ProgramInterface* RTT::scripting::StateMachine::currentRun [private]

Definition at line 675 of file StateMachine.hpp.

ProgramInterface* RTT::scripting::StateMachine::currentTrans [private]

Definition at line 676 of file StateMachine.hpp.

std::string RTT::StateMachine::emptyString [static, private]

Definition at line 77 of file StateMachine.hpp.

int RTT::scripting::StateMachine::evaluating [private]

Definition at line 685 of file StateMachine.hpp.

EventMap RTT::scripting::StateMachine::eventMap [protected]

A map keeping track of all events of a state. Not all states need to be present as a key in this map.

Definition at line 618 of file StateMachine.hpp.

os::MutexRecursive RTT::scripting::StateMachine::execlock [private]

Definition at line 687 of file StateMachine.hpp.

StateInterface* RTT::scripting::StateMachine::finistate [private]

The Final State.

Definition at line 656 of file StateMachine.hpp.

base::ActionInterface* RTT::scripting::StateMachine::initc [private]

Definition at line 669 of file StateMachine.hpp.

StateInterface* RTT::scripting::StateMachine::initstate [private]

The Initial State.

Definition at line 651 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::mstep [private]

Definition at line 683 of file StateMachine.hpp.

bool RTT::scripting::StateMachine::mtrace [private]

Definition at line 683 of file StateMachine.hpp.

StateInterface* RTT::scripting::StateMachine::next [private]

The next state the Machine will go to.

Definition at line 667 of file StateMachine.hpp.

std::pair<PreConditionMap::const_iterator,PreConditionMap::const_iterator> RTT::scripting::StateMachine::prec_it [private]

Definition at line 681 of file StateMachine.hpp.

PreConditionMap RTT::scripting::StateMachine::precondMap [protected]

A map keeping track of all preconditions of a state. Not all states need to be present as a key in this map.

Definition at line 612 of file StateMachine.hpp.

TransList::iterator RTT::scripting::StateMachine::reqend [private]

Definition at line 679 of file StateMachine.hpp.

TransList::iterator RTT::scripting::StateMachine::reqstep [private]

Definition at line 678 of file StateMachine.hpp.

enum RTT::scripting::StateMachine::PrivateStatus RTT::scripting::StateMachine::smpStatus [private]

Status::StateMachineStatus RTT::scripting::StateMachine::smStatus [protected]

Definition at line 105 of file StateMachine.hpp.

TransitionMap RTT::scripting::StateMachine::stateMap [protected]

A map keeping track of all States and conditional transitions between two states. Every state of this StateMachine must be] present as a key in this map.

Definition at line 606 of file StateMachine.hpp.

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

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation