methods

Like any other front-end, Row implements the two necessary static
functions for action and guard call. Each function receives as parameter
the (deepest-level) state machine processsing the event, the event
itself, the source and target states and all the states contained in a
state machine.

methods

Like any other front-end, Internal implements the two necessary static
functions for action and guard call. Each function receives as parameter
the (deepest-level) state machine processsing the event, the event
itself, the source and target states and all the states contained in a
state machine.

msm/front/internal_row.hpp

This header implements the internal transition rows for use inside an
internal_transition_table. All these row types have no source or target state,
as the backend will recognize internal transitions from this
internal_transition_table.

methods

Like any other front-end, the following transition row types implements
the two necessary static functions for action and guard call. Each function
receives as parameter the (deepest-level) state machine processsing the
event, the event itself, the source and target states and all the states
contained in a state machine.

template parameters

CalledForAction: the type on which the action method will
be called. It can be either a state of the containing state
machine or the state machine itself.

action: a pointer to the method which CalledForAction
provides.

CalledForGuard: the type on which the guard method will be
called. It can be either a state of the containing state
machine or the state machine itself.

guard: a pointer to the method which CalledForGuard
provides.

_internal

This is an internal transition without action or guard. This is equivalent
to an explicit "ignore event".

definition

template< class Event > _internal {}

template parameters

Event: the event triggering the internal
transition.

msm/front/row2.hpp

This header contains the variants of row2, which are an extension of the
standard row transitions for use in the transition table. They offer the
possibility to define action and guard not only in the state machine, but in any
state of the state machine. They can also be used in internal transition tables
through their irow2 variants.

methods

Like any other front-end, the following transition row types implements
the two necessary static functions for action and guard call. Each function
receives as parameter the (deepest-level) state machine processsing the
event, the event itself, the source and target states and all the states
contained in a state machine.

template parameters

CalledForAction: the type on which the action method will
be called. It can be either a state of the containing state
machine or the state machine itself.

action: a pointer to the method which CalledForAction
provides.

CalledForGuard: the type on which the guard method will be
called. It can be either a state of the containing state
machine or the state machine itself.

guard: a pointer to the method which CalledForGuard
provides.

msm/front/state_machine_def.hpp

This header provides the implementation of the basic front-end. It contains one
type, state_machine_def

state_machine_def definition

This type is the basic class for a basic (or possibly any other)
front-end. It provides the standard row types (which includes internal
transitions) and a default implementation of the required methods and
typedefs.

typedefs

flag_list: by default, no flag is set in the state
machine

deferred_events: by default, no event is deferred.

configuration: by default, no configuration customization
is done.

row methods

Like any other front-end, the following transition row types
implements the two necessary static functions for action and guard call.
Each function receives as parameter the (deepest-level) state machine
processsing the event, the event itself, the source and target states
and all the states contained in a state machine (ignored).

action: a pointer to the method provided by the concrete
front-end (represented by Derived).

guard: a pointer to the method provided by the concrete
front-end (represented by Derived).

_irow

This is an internal transition without action or guard. As it does
nothing, it means "ignore event".

template< class Source, class Event >
_irow

Event: the event triggering the transition.

Source: the source state of the transition.

methods

state_machine_def provides a default implementation in
case of an event which cannot be processed by a state machine (no
transition found). The implementation is using a
BOOST_ASSERT so that the error will only be noticed in
debug mode. Overwrite this method in your implementation to change the
behavior.

template <class Fsm,class Event> static void
no_transition(

);

(Event const& ,Fsm&, int
state);

state_machine_def provides a default implementation in
case an exception is thrown by a state (entry/exit) or transition
(action/guard) behavior. The implementation is using a
BOOST_ASSERT so that the error will only be noticed in
debug mode. Overwrite this method in your implementation to change the
behavior. This method will be called only if exception handling is not
deactivated (default) by defining
has_no_message_queue.

template <class Fsm,class Event> static void
exception_caught(

);

(Event const& ,Fsm&,
std::exception&);

msm/front/states.hpp

This header provides the different states (except state machines) for the
basic front-end (or mixed with other front-ends).

types

This header provides the following types:

no_sm_ptr

deprecated: default policy for states. It means that states do not
need to save a pointer to their containing state machine.

sm_ptr

deprecated: state policy. It means that states need to save a pointer
to their containing state machine. When seeing this flag, the back-end
will call set_sm_ptr(fsm*) and give itself as argument.

state

Basic type for simple states. Inherit from this type to define a
simple state. The first argument is needed if you want your state (and
all others used in a concrete state machine) to inherit a basic type for
logging or providing a common behavior.

terminate_state

Basic type for terminate states. Inherit from this type to define a
terminate state. The first argument is needed if you want your state
(and all others used in a concrete state machine) to inherit a basic
type for logging or providing a common behavior.

interrupt_state

Basic type for interrupt states. Interrupt states prevent any further
event handling until EndInterruptEvent is sent. Inherit from this type
to define a terminate state. The first argument is the name of the event
ending the interrupt. The second argument is needed if you want your
state (and all others used in a concrete state machine) to inherit a
basic type for logging or providing a common behavior.

template<class EndInterruptEvent,class Base =
default_base_state, {}

class SMPtrPolicy = no_sm_ptr>
interrupt_state {}

explicit_entry

Inherit from this type in
addition to the desired state type to enable this state
for direct entering. The template parameter gives the region id of the
state (regions are numbered in the order of the
initial_state typedef).

template <int ZoneIndex=-1> explicit_entry {}

entry_pseudo_state

Basic type for entry pseudo states. Entry pseudo states are an
predefined entry into a submachine and connect two transitions. The
first argument is the id of the region entered by this state (regions
are numbered in the order of the initial_state typedef).
The second argument is needed if you want your state (and all others
used in a concrete state machine) to inherit a basic type for logging or
providing a common behavior.

template<int RegionIndex=-1,class Base =
default_base_state, {}

class SMPtrPolicy = no_sm_ptr>
entry_pseudo_state {}

exit_pseudo_state

Basic type for exit pseudo states. Exit pseudo states are an
predefined exit from a submachine and connect two transitions. The first
argument is the name of the event which will be "thrown" out of the exit
point. This event does not need to be the same as the one sent by the
inner region but must be convertible from it. The second argument is
needed if you want your state (and all others used in a concrete state
machine) to inherit a basic type for logging or providing a common
behavior.

template<class Event,class Base =
default_base_state, {}

class SMPtrPolicy = no_sm_ptr>
exit_pseudo_state {}

msm/front/euml/euml.hpp

This header includes all of eUML except the STL functors.

msm/front/euml/stl.hpp

This header includes all the functors for STL support in eUML. These tables show a full description.

msm/front/euml/algorithm.hpp

This header includes all the functors for STL algorithms support in eUML.
These tables show a full
description.

msm/front/euml/iteration.hpp

This header includes iteration functors for STL support in eUML. This tables shows a full
description.

msm/front/euml/querying.hpp

This header includes querying functors for STL support in eUML. This tables shows a full
description.

msm/front/euml/transformation.hpp

This header includes transformation functors for STL support in eUML. This
tables shows a full
description.

msm/front/euml/container.hpp

This header includes container functors for STL support in eUML (functors
calling container methods). This tables shows a full description. It also provides npos for
strings.

Npos_<container type>

Functor returning npos for transition or state behaviors. Like all
constants, only the functor form exists, so parenthesis are necessary.
Example:

string_find_(event_(m_song),Char_<'S'>(),Size_t_<0>()) !=
Npos_<string>() // compare result of string::find with
npos

msm/front/euml/stt_grammar.hpp

This header provides the transition table grammars. This includes internal
transition tables.

functions

build_stt

The function build_stt evaluates the grammar-conform expression as
parameter. It returns a transition table, which is a mpl::vector of
transitions (rows) or, if the expression is ill-formed (does not match
the grammar), the type invalid_type, which will lead to a
compile-time static assertion when this transition table is passed to a
state machine.

build_internal_stt

The function build_internal_stt evaluates the grammar-conform
expression as parameter. It returns a transition table, which is a
mpl::vector of transitions (rows) or, if the expression is ill-formed
(does not match the grammar), the type invalid_type, which
will lead to a compile-time static assertion when this transition table
is passed to a state machine.

The grammars Action and Guard are defined in state_grammar.hpp and
guard_grammar.hpp respectively. state_tag and event_tag are inherited
from euml_state (or other state variants) and euml_event respectively.
For example, following declarations are possible:

Most C++ operators are supported (address-of is not). With
function is meant any eUML predefined function or any self-made
(using MSM_EUML_METHOD or MSM_EUML_FUNCTION). Action
is a grammar defined in state_grammar.hpp.

msm/front/euml/state_grammar.hpp

This header provides the grammar for actions and the different grammars and
functions to build states using eUML.

action grammar

Like the guard grammar, this grammar supports relevant C++ operators and
eUML functions:

initial states

The grammar to define initial states for a state machine is: init_
<< state_1 << ... << state_n where
state_1...state_n inherit from euml_state or is defined using
BOOST_MSM_EUML_STATE, BOOST_MSM_EUML_INTERRUPT_STATE,
BOOST_MSM_EUML_TERMINATE_STATE, BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE,
BOOST_MSM_EUML_ENTRY_STATE or BOOST_MSM_EUML_EXIT_STATE.

functions

build_sm

This function has several overloads. The return type is not relevant
to you as only decltype (return type) is what one needs.

Notice that this function requires the extra parameter class
StateNameTag to disambiguate states having the same parameters but still
being different.

build_explicit_entry_state

This function has the same overloads as build_entry_state and
explicit_entry_func_state as return type.

msm/front/euml/common.hpp

types

euml_event

The basic type for events with eUML.

template <class EventName> euml_event; {}

struct play : euml_event<play>{};

euml_state

The basic type for states with eUML. You will usually not use this
type directly as it is easier to use BOOST_MSM_EUML_STATE,
BOOST_MSM_EUML_INTERRUPT_STATE, BOOST_MSM_EUML_TERMINATE_STATE,
BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE, BOOST_MSM_EUML_ENTRY_STATE or
BOOST_MSM_EUML_EXIT_STATE.

template <class StateName> euml_state; {}

You can however use this type directly if you want to provide your
state with extra functions or provide entry or exit behaviors without
functors, for example:

euml_config

You normally do not use this type directly but instead the instances
of predefined configuration:

no_exception: disable catching exceptions

no_msg_queue: disable message queue. The message queue
allows you to send an event for procesing while in an event
processing.

deferred_events: manually enable handling of deferred
events

invalid_type

Type returned by grammar parsers if the grammar is invalid. Seeing
this type will result in a static assertion.

no_action

Placeholder type for use in entry/exit or transition behaviors, which
does absolutely nothing.

source_

Generic object or function for the source state of a given transition:

as object: returns by reference the source state of a
transition, usually to be used by another function (usually
one created by MSM_EUML_METHOD or MSM_EUML_FUNCTION).

Example:

some_user_function_(source_)

as function: returns by reference the attribute passed as
parameter.

Example:

source_(m_counter)++

target_

Generic object or function for the target state of a given transition:

as object: returns by reference the target state of a
transition, usually to be used by another function (usually
one created by MSM_EUML_METHOD or MSM_EUML_FUNCTION).

Example:

some_user_function_(target_)

as function: returns by reference the attribute passed as
parameter.

Example:

target_(m_counter)++

state_

Generic object or function for the state of a given entry / exit
behavior. state_ means source_ while in the context of an exit behavior
and target_ in the context of an entry behavior:

as object: returns by reference the current state, usually
to be used by another function (usually one created by
MSM_EUML_METHOD or MSM_EUML_FUNCTION).

Example:

some_user_function_(state_) // calls some_user_function on the current state

as function: returns by reference the attribute passed as
parameter.

Example:

state_(m_counter)++

event_

Generic object or function for the event triggering a given transition
(valid in a transition behavior, as well as in state entry/exit behaviors):

as object: returns by reference the event of a transition,
usually to be used by another function (usually one created
by MSM_EUML_METHOD or MSM_EUML_FUNCTION).

Example:

some_user_function_(event_)

as function: returns by reference the attribute passed as
parameter.

Example:

event_(m_counter)++

fsm_

Generic object or function for the state machine containing a given transition:

as object: returns by reference the event of a transition,
usually to be used by another function (usually one created
by MSM_EUML_METHOD or MSM_EUML_FUNCTION).

Example:

some_user_function_(fsm_)

as function: returns by reference the attribute passed as
parameter.

Example:

fsm_(m_counter)++

substate_

Generic object or function returning a state of a given state machine:

with 1 parameter: returns by reference the state passed as
parameter, usually to be used by another function (usually
one created by MSM_EUML_METHOD or MSM_EUML_FUNCTION).

Example:

some_user_function_(substate_(my_state))

with 2 parameters: returns by reference the state passed
as first parameter from the state machine passed as second
parameter, usually to be used by another function (usually
one created by MSM_EUML_METHOD or MSM_EUML_FUNCTION). This
makes sense when used in combination with attribute_.

Example (equivalent to the previous example):

some_user_function_(substate_(my_state,fsm_))

attribute_

Generic object or function returning the attribute passed (by name) as
second parameter of the thing passed as first (a state, event or state
machine). Example:

attribute_(substate_(my_state),cd_name_attribute)++

True_

Functor returning true for transition or state behaviors. Like all
constants, only the functor form exists, so parenthesis are necessary.
Example:

if_then_(True_(),/* some action always called*/)

False_

Functor returning false for transition or state behaviors. Like all
constants, only the functor form exists, so parenthesis are necessary.
Example:

if_then_(False_(),/* some action never called */)

Int_<int value>

Functor returning an integer value for transition or state behaviors.
Like all constants, only the functor form exists, so parenthesis are
necessary. Example:

is_flag_

This function tells if a flag is active by calling
is_flag_active on the current state machine or one
passed as parameter:

is_flag_(some_flag) : calls
is_flag_active on the current (containing)
state machine.

is_flag_(some_flag, some_fsm) :calls
is_flag_active on the state machine.passed
as argument.

defer_

This object defers the current event by calling
defer_event on the current state machine.
Example:

Empty() + play() / defer_

explicit_(submachine-name,state-name)

Used as transition's target, causes an explicit entry into the given
state from the given submachine. Several explicit_ as targets, separated
by commas, means a fork. The state must have been declared as such using
BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE.

entry_pt_(submachine-name,state-name)

Used as transition's target from a containing state machine, causes
submachine-name to be entered using the given entry pseudo-state. This
state must have been declared as pseudo entry using
BOOST_MSM_EUML_ENTRY_STATE.

exit_pt_(submachine-name,state-name)

Used as transition's source from a containing state machine, causes
submachine-name to be left using the given exit pseudo-state. This state
must have been declared as pseudo exit using
BOOST_MSM_EUML_EXIT_STATE.

MSM_EUML_FUNCTION

This macro creates a eUML function and a functor for use with the
functor front-end, based on a free function:

first parameter: the name of the functor

second parameter: the underlying function

third parameter: the eUML function name

fourth parameter: the return type if used in a transition
behavior

fifth parameter: the return type if used in a state
behavior (entry/exit)

BOOST_MSM_EUML_FLAG(flag-instance-name)

This macro declares a flag type and a const instance for use in
behaviors.

BOOST_MSM_EUML_FLAG_NAME(flag-instance-name)

This macro returns the name of the flag type generated by
BOOST_MSM_EUML_FLAG. You need this where the type is required (usually
with the back-end method is_flag_active). For example:

fsm.is_flag_active<BOOST_MSM_EUML_FLAG_NAME(CDLoaded)>()

BOOST_MSM_EUML_DECLARE_ATTRIBUTE(event-type,event-name)

This macro declares an attribute called event-name of type event-type.
This attribute can then be made part of an attribute list using
BOOST_MSM_EUML_ATTRIBUTES.

BOOST_MSM_EUML_ATTRIBUTES(attributes-expression,attributes-name)

This macro declares an attribute list called attributes-name based on
the expression as first argument. These attributes can then be made part
of an event using BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES, of a state as
3rd parameter of BOOST_MSM_EUML_STATE or of a state machine as 5th
parameter of BOOST_MSM_EUML_DECLARE_STATE_MACHINE.

BOOST_MSM_EUML_EVENT(event-instance name)

This macro defines an event type (event-instance-name_helper) and
declares a const instance of this event type called event-instance-name
for use in a transition table or state behaviors.

BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(event-instance-name,attributes)

This macro defines an event type (event-instance-name_helper) and
declares a const instance of this event type called event-instance-name
for use in a transition table or state behaviors. The event will have as
attributes the ones passed by the second argument:

BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(Found,FoundDef)

The created event instance supports operator()(attributes) so that

my_back_end.process_event(Found(some_string))

is possible.

BOOST_MSM_EUML_EVENT_NAME(event-instance-name)

This macro returns the name of the event type generated by
BOOST_MSM_EUML_EVENT or BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES. You need
this where the type is required (usually inside a back-end definition).
For example:

(Expr1,Expr2,Attributes,Configure,Base): state with entry
and exit action, defining some attributes, flags and
deferred events (plain msm deferred events) and a
non-default base state (as defined in standard MSM).

BOOST_MSM_EUML_INTERRUPT_STATE(build-expression,state-instance-name)

This macro defines an interrupt state type
(state-instance-name_helper) and declares a const instance of this state
type called state-instance-name for use in a transition table or state
behaviors.

There are several possibilitites for the expression syntax. In all of
them, the first argument is the name of the event (generated by one of
the previous macros) ending the interrupt:

(end_interrupt_event): interrupt state without entry or
exit action.

(end_interrupt_event,Expr1): interrupt state with entry
but no exit action.

(end_interrupt_event,Expr1,Expr2): interrupt state with
entry and exit action.

(end_interrupt_event,Expr1,Expr2,Attributes): interrupt
state with entry and exit action, defining some
attributes.

(end_interrupt_event,Expr1,Expr2,Attributes,Configure,Base):
interrupt state with entry and exit action, defining some
attributes, flags and deferred events (plain msm deferred
events) and a non-default base state (as defined in standard
MSM).

BOOST_MSM_EUML_TERMINATE_STATE(build-expression,state-instance-name)

This macro defines a terminate pseudo-state type
(state-instance-name_helper) and declares a const instance of this state
type called state-instance-name for use in a transition table or state
behaviors.

This macro defines a submachine's substate type
(state-instance-name_helper), which can be explicitly entered and also
declares a const instance of this state type called state-instance-name
for use in a transition table or state behaviors.

There are several possibilitites for the expression syntax:

(): state without entry or exit action.

(Expr1): state with entry but no exit action.

(Expr1,Expr2): state with entry and exit action.

(Expr1,Expr2,Attributes): state with entry and exit
action, defining some attributes.

(Expr1,Expr2,Attributes,Configure,Base): state with entry
and exit action, defining some attributes, flags and
deferred events (plain msm deferred events) and a
non-default base state (as defined in standard MSM).

BOOST_MSM_EUML_STATE_NAME(state-instance-name)

This macro returns the name of the state type generated by
BOOST_MSM_EUML_STATE or other state macros. You need this where the type
is required (usually using a backend function). For example:

Like BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE but does not provide an
instance, simply a type declaration.

BOOST_MSM_EUML_TRANSITION_TABLE(expression,
table-instance-name)

This macro declares a transition table type and also declares a const
instance of the table which can then be used in a state machine
declaration (see BOOST_MSM_EUML_DECLARE_STATE_MACHINE).The expression
must follow the transition
table grammar.