Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r61070 - in sandbox/msm/libs/msm/doc: . HTML HTML/examples HTML/examples/distributed_table HTML/examples/iPod_distributed PDF images src
From: christophe.j.henry_at_[hidden]
Date: 2010-04-05 08:14:24


Author: chenry
Date: 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
New Revision: 61070
URL: http://svn.boost.org/trac/boost/changeset/61070

Log:
new doc (V2.10)
Added:
   sandbox/msm/libs/msm/doc/
   sandbox/msm/libs/msm/doc/HTML/
   sandbox/msm/libs/msm/doc/HTML/ar01s02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ar01s03.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ar01s04.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ar01s05.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ar01s06.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ar01s07.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ar01s08.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ar01s09.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/boost.css (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/boostbook.css (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch01.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch02s02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch02s03.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch03.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch03s02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch03s03.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch03s04.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch03s05.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch04.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch04s02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch04s03.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch04s04.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch04s05.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch05.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch06.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch06s02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch06s03.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch06s04.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch07.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch07s02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch08.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch08s02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch08s03.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch09.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/ch10.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/docutils.css (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/
   sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorial.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorialEuml.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorialWithFunctors.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/BoostCon09Full.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/CompilerStressTestEuml.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/CompositeTutorial.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/CompositeTutorialEuml.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/DirectEntryEuml.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/DirectEntryTutorial.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/EumlInternal.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/EumlInternalDistributed.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/EumlSimple.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/Flags.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/MsmComposite.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/MsmSimple.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/MsmSimpleFunctors.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/Orthogonal-deferred.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/Orthogonal-deferred2.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/OrthogonalDeferredEuml.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/OrthogonalDeferredEuml2.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/ParsingDigits.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SC Composite.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SC Simple.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SM-2Arg.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleTimer.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleTutorial.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleTutorial2.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleTutorialEuml.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleTutorialEuml2.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleTutorialInternal.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleTutorialInternal2.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleTutorialInternalFunctors.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleWithFunctors.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleWithFunctors2.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/SimpleWithFunctors3.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/TestInternal.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/char_event_dispatcher.hpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/distributed_table/
   sandbox/msm/libs/msm/doc/HTML/examples/distributed_table/DistributedTable.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/distributed_table/Empty.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/distributed_table/Empty.hpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/distributed_table/Events.hpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/distributed_table/Open.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/distributed_table/Open.hpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPodEuml.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPodSearch.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPodSearchEuml.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPod_distributed/
   sandbox/msm/libs/msm/doc/HTML/examples/iPod_distributed/Events.hpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPod_distributed/MenuMode.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPod_distributed/MenuMode.hpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPod_distributed/PlayingMode.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPod_distributed/PlayingMode.hpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/iPod_distributed/iPod.cpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/ipod_functors.hpp (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/examples/logging_functors.h (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/index.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/minimal.css (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/pr01.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/pt01.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/pt02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/re01.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/re02.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/re03.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/reference.css (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/rn01.html (contents, props changed)
   sandbox/msm/libs/msm/doc/HTML/rn01re01.html (contents, props changed)
   sandbox/msm/libs/msm/doc/PDF/
   sandbox/msm/libs/msm/doc/PDF/msm.pdf (contents, props changed)
   sandbox/msm/libs/msm/doc/images/
   sandbox/msm/libs/msm/doc/images/AnnexA.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/Anonymous.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/CompositeTutorial.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/FlagsTutorial.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/HistoryTutorial.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/Orthogonal-deferred.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/ParsingDigits.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/SimpleTutorial.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/completion.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/conflict1.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/conflict2.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/entry tutorial.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/entry_point.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/error_no_regions.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/images/exit.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/explicit.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/fork.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/history.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/init_state.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/regions.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/sm.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/state.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/terminate.gif (contents, props changed)
   sandbox/msm/libs/msm/doc/images/transition.jpg (contents, props changed)
   sandbox/msm/libs/msm/doc/src/
   sandbox/msm/libs/msm/doc/src/msm.xml (contents, props changed)

Added: sandbox/msm/libs/msm/doc/HTML/ar01s02.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ar01s02.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,20 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Founding idea</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="index.html" title="Meta State Machine (MSM)"><link rel="prev" href="index.html" title="Meta State Machine (MSM)"><link rel="next" href="ar01s03.html" title="UML Short Guide"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Founding idea</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="index.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ar01s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Founding idea"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e99"></a>Founding idea</h2></div></div></div><p>Let's start with an example taken
 from the C++ Template Metaprogramming book:</p><p>
+ <code class="code">class player : public state_machine&lt;player&gt;</code></p><p><code class="code">{ </code></p><p><code class="code">// The list of FSM states enum states { Empty, Open, Stopped, Playing, Paused ,
+ initial_state = Empty }; </code></p><p><code class="code">// transition actions void start_playback(play const&amp;) { std::cout &lt;&lt;
+ "player::start_playback\n"; } </code></p><p><code class="code">void open_drawer(open_close const&amp;) { std::cout &lt;&lt;
+ "player::open_drawer\n"; } </code></p><p><code class="code">void close_drawer(open_close const&amp;) { std::cout &lt;&lt;
+ "player::close_drawer\n"; } </code></p><p><code class="code">void store_cd_info(cd_detected const&amp;) { std::cout &lt;&lt;
+ "player::store_cd_info\n"; } </code></p><p><code class="code">void stop_playback(stop const&amp;) { std::cout &lt;&lt;
+ "player::stop_playback\n"; } </code></p><p><code class="code">void pause_playback(pause const&amp;) { std::cout &lt;&lt;
+ "player::pause_playback\n"; } </code></p><p><code class="code">void resume_playback(play const&amp;) { std::cout &lt;&lt;
+ "player::resume_playback\n"; } </code></p><p><code class="code">void stop_and_open(open_close const&amp;) { std::cout &lt;&lt;
+ "player::stop_and_open\n"; } </code></p><p><code class="code">friend class state_machine&lt;player&gt;; </code></p><p><code class="code">typedef player p; // makes transition table cleaner </code></p><p><code class="code">// Transition table </code></p><p><code class="code">struct transition_table : mpl::vector11&lt; </code></p><p><code class="code">row &lt; Stopped , play , Playing , &amp;p::start_playback &gt;, </code></p><p><code class="code">row &lt; Stopped , open_close , Open , &amp;p::open_drawer &gt;, </code></p><p><code class="code">row &lt; Open , open_close , Empty , &amp;p::close_drawer &gt;, </code></p><p><code class="code">row &lt; Empty , open_close , Open , &amp;p::open_drawer &gt;, </code></p><p><code class="code">row &lt; Empty , cd_detected , Stopped , &amp;p::store_cd_info &gt;, </code></p><p><code class="code">row &lt; Playing , stop , Stopped , &amp;p::stop_playback &gt;, </code></p><p><code class="code">row &lt; Playing , pause , Paused , &amp;p::pause_playback &gt;, <
/code></p><p><code class="code">row &lt; Playing , open_close , Open , &amp;p::stop_and_open &gt;, </code></p><p><code class="code">row &lt; Paused , play , Playing , &amp;p::resume_playback &gt;, </code></p><p><code class="code">row &lt; Paused , stop , Stopped , &amp;p::stop_playback &gt;, </code></p><p><code class="code">row &lt; Paused , open_close , Open , &amp;p::stop_and_open &gt; </code></p><p><code class="code">&gt; {}; </code></p><p><code class="code">// Replaces the default no-transition response. </code></p><p><code class="code">template &lt;class Event&gt; int no_transition(int state, Event const&amp; e) {
+ std::cout &lt;&lt; "no transition from state " &lt;&lt; state &lt;&lt; " on event "
+ &lt;&lt; typeid(e).name() &lt;&lt; std::endl; return state; } };</code>
+ </p><p><code class="code">void test() { player p; p.process_event(open_close());...}</code></p><p>This example is the foundation for the idea driving MSM: a descriptive and expressive
+ language based on a transition table with as little syntactic noise as possible, all
+ this while offering as many features from the UML 2.0 standard as possible. MSM also
+ offers several expressive state machine definition syntaxes with different
+ trade-offs.</p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="index.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ar01s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Meta State Machine (MSM)&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;UML Short Guide</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ar01s03.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ar01s03.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,122 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>UML Short Guide</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="index.html" title="Meta State Machine (MSM)"><link rel="prev" href="ar01s02.html" title="Founding idea"><link rel="next" href="ar01s04.html" title="User's Guide"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">UML Short Guide</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ar01s04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="UML Short Guide"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e198"></a>UML Short Guide</h2></div></div></div><div class="sect2" title="What are st
ate machines?"><div class="titlepage"><div><div><h3 class="title"><a name="d0e201"></a>What are state machines?</h3></div></div></div><p>State machines are the description of the lifeline of a thing. They describe the
+ different stages of the lifeline, the events influencing it, and what it does when a
+ particular event is detected at a particular stage. They offer the complete
+ specification of the dynamic behavior of the thing.</p></div><div class="sect2" title="Concepts"><div class="titlepage"><div><div><h3 class="title"><a name="d0e206"></a>Concepts</h3></div></div></div><div class="sect3" title="State machine, state, transition, event"><div class="titlepage"><div><div><h4 class="title"><a name="d0e209"></a>State machine, state, transition, event </h4></div></div></div><p>Thinking in terms of state machines is a bit surprising at first, so let us
+ have a quick glance at the concepts.</p><p>A state machine is a concrete model describing the behavior of a system. It is
+ composed of a finite number of states and transitions.</p><p>
+ <span class="inlinemediaobject"><img src="../images/sm.gif"></span></p><p>A simple state has no sub states. It can have data, entry and exit behaviors
+ and deferrable events. One can add entry and exit conditions to states (or state
+ machines), which are executed whenever a state is entered or left, no matter
+ how. A state can also have internal transitions which cause no entry or exit
+ action to be called. A state can mark events as deferred. This means the event
+ cannot be processed if this state is active, but it must be retained. Next time
+ a state not deferring this event is active, the event will be processed, as if
+ it had just been detected. </p><p><span class="inlinemediaobject"><img src="../images/state.gif"></span></p><p>A transition is the switching between active states, triggered by an event.
+ Actions and guard conditions can be attached to the transition. The action is
+ executes when the transition fires, the guard is a Boolean operation executed
+ first and which can prevent the transition from firing if returning
+ false.</p><p>
+ <span class="inlinemediaobject"><img src="../images/transition.jpg"></span></p><p>An initial state marks the first active state of a state machine. It has no
+ real existence and neither has the transition originating from it.</p><p>
+ <span class="inlinemediaobject"><img src="../images/init_state.gif"></span></p></div><div class="sect3" title="Submachines, orthogonal regions, pseudostates"><div class="titlepage"><div><div><h4 class="title"><a name="d0e241"></a>Submachines, orthogonal regions, pseudostates </h4></div></div></div><p>A composite state is a state containing a region or decomposed in two or more
+ regions. A composite state contains its own set of states and regions. </p><p>A submachine is a state machine inserted as a state in another state machine.
+ The same state machine can be inserted more than once. </p><p>Orthogonal regions are parts of a composite state or submachine, each having
+ its own set of mutually exclusive set of states and transitions. </p><p><span class="inlinemediaobject"><img src="../images/regions.gif"></span></p><p>UML also defines a number of pseudo states, which are considered important
+ concepts to model, but not enough to make them first-class citizens. The
+ terminate pseudo state terminates the execution of a state machine (MSM handles
+ this slightly differently. The state machine is not destroyed but no further
+ event processing occurs.). </p><p><span class="inlinemediaobject"><img src="../images/terminate.gif"></span></p><p>An exit point pseudo state exits a composite state or a submachine and forces
+ termination of execution in all contained regions.</p><p><span class="inlinemediaobject"><img src="../images/exit.gif"></span></p><p>An entry point pseudo state allows a kind of controlled entry inside a
+ composite. Precisely, it connects a transition outside the composite to a
+ transition inside the composite. An important point is that this mechanism only
+ allows a single region to be entered. In the above diagram, in region1, the
+ initial state would become active. </p><p><span class="inlinemediaobject"><img src="../images/entry_point.gif"></span></p><p>There are also two more ways to enter a composite state (apart the obvious and
+ more common case of a transition terminating on the composite as shown in the
+ region case). An explicit entry means that an inside state is the target of a
+ transition. Unlike with direct entry, no tentative encapsulation is made, and
+ only one transition is executed. Needless to say, I would not recommend using
+ this. </p><p><span class="inlinemediaobject"><img src="../images/explicit.gif"></span></p><p>The last entry possibility is using fork. A fork is an explicit entry into one
+ or more regions. Other regions are again activated using their initial state. </p><p><span class="inlinemediaobject"><img src="../images/fork.gif"></span></p></div><div class="sect3" title="History"><div class="titlepage"><div><div><h4 class="title"><a name="d0e284"></a>
+ <span class="command"><strong><a name="uml-history"></a></strong></span>History </h4></div></div></div><p>UML defines two sorts of history, shallow history and deep history. Shallow
+ history is a pseudo state representing the most recent substate of a composite
+ or submachine. A composite can have at most one shallow history. A transition
+ with a history pseudo state as target is equivalent to a transition with the
+ most recent substate as target. And very importantly, only one transition may
+ originate from the history. Deep history is a shallow history recursively
+ reactivating the substates of the most recent substate. It is represented like
+ the shallow history with a star (H* inside a circle).</p><p>
+ <span class="inlinemediaobject"><img src="../images/history.gif"></span></p><p>History is not a completely satisfying concept. First of all, there can be
+ just one history pseudo state and only one transition may originate from it. So
+ they do not mix well with orthogonal regions as only one region can be
+ &#8220;remembered&#8221;. Deep history is even worse and looks like a last-minute addition.
+ History has to be activated by a transition and only one transition originates
+ from it, so how to model the transition originating from the deep history pseudo
+ state and pointing to the most recent substate of the substate? As a bonus, it
+ is also inflexible and does not accept new types of histories. Let's face it,
+ history sounds great and is useful in theory, but the UML version is not quite
+ making the cut. And therefore, MSM provides a different version of it. </p></div><div class="sect3" title="Completion events / anonymous transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e298"></a><span class="command"><strong><a name="uml-anonymous"></a></strong></span>Completion events / anonymous
+ transitions</h4></div></div></div><p>Completion events, also called anonymous transitions, are defined as
+ transitions having no defined event triggering them. This means that such
+ transitions will immediately fire when a state being the source of an anonymous
+ transition becomes active, provided that a guard allows it. They are useful in
+ modeling algorithms as an activity diagram would normally do. In the real-time
+ world, they have the advantage of being able to estimate how long a periodically
+ executed action will last. For example, consider the following diagram. </p><p><span class="inlinemediaobject"><img src="../images/completion.gif"></span></p><p>The designer now knows at any time that he will need a maximum of 4
+ transitions. Being able to estimate how long a transition takes, he can estimate
+ how much of a time frame he will need to require (real-time applications are
+ often executed at regular intervals). If he can also estimate the duration of
+ actions, he can even use graph algorithms to better estimate his timing
+ requirements. </p></div><div class="sect3" title="Internal transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e310"></a><span class="command"><strong><a name="UML-internal-transition"></a></strong></span> Internal transitions </h4></div></div></div><p>Internal transitions are transitions executing in the scope of the active
+ state, being a simple state or a submachine. One can see them as a
+ self-transition of this state, without an entry or exit action called.</p></div><div class="sect3" title="Conflicting transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e316"></a>
+ <span class="command"><strong><a name="transition-conflict"></a></strong></span>Conflicting transitions </h4></div></div></div><p>If, for a given event, several transitions are enabled, they are said to be in
+ conflict. There are two kinds of conflicts: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>For a given source state, several transitions are defined,
+ triggered by the same event. Normally, the guard condition in each
+ transition defines which one is fired.</p></li><li class="listitem"><p>The source state is a submachine or simple state and the conflict
+ is between a transition internal to this state and a transition
+ triggered by the same event and having as target another
+ state.</p></li></ul></div><p>The first one is simple; one only needs to define two or more
+ rows in the transition table, with the same source and trigger, with a different
+ guard condition. Beware, however, that the UML standard wants these conditions
+ to be not overlapping. If they do, the standard says nothing except that this is
+ incorrect, so the implementer is free to implement it the way he sees fit. In
+ the case of MSM, the transition appearing last in the transition table gets
+ selected first, if it returns false (meaning disabled), the library tries with
+ the previous one, and so on.</p><p>
+ <span class="inlinemediaobject"><img src="../images/conflict1.gif"></span></p><p>In the second case, UML defines that the most inner transition gets selected
+ first, which makes sense, otherwise no exit point pseudo state would be possible
+ (the inner transition brings us to the exit point, from where the containing
+ state machine can take over). </p><p><span class="inlinemediaobject"><img src="../images/conflict2.gif"></span></p><p>Msm handles all these cases itself, so the designer needs only concentrate on
+ its state machine and the UML subtleties (not overlapping conditions), not on
+ implementing this behavior himself. </p></div></div><div class="sect2" title="State machine glossary"><div class="titlepage"><div><div><h3 class="title"><a name="d0e344"></a>State machine glossary</h3></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>state machine: the lifecycle of a thing. It is made of states,
+ regions, transitions and processes incoming events.</p></li><li class="listitem"><p>state: a stage in the lifecycle of a state machine. A state (like a
+ submachine) can have an entry and exit action.</p></li><li class="listitem"><p>event: an incident provoking (or not) a reaction of the state
+ machine</p></li><li class="listitem"><p>transition: a specification of how a state machine reacts to an event.
+ It specifies a source state, the event triggering the transition, the
+ target state (which will become the newly active state if the transition
+ is triggered), guard and actions.</p></li><li class="listitem"><p>action: an operation executed during the triggering of the
+ transition.</p></li><li class="listitem"><p>guard: a boolean operation being able to prevent the triggering of a
+ transition which would otherwise fire.</p></li><li class="listitem"><p>transition table: representation of a state machine. A state machine
+ diagram is another but incomplete representation of the same
+ model.</p></li><li class="listitem"><p>initial state: The state in which the state machine starts. Having
+ several orthogonal regions means having as many initial states.</p></li><li class="listitem"><p>composite / submachine: A composite state is a state which is itself a
+ state machine. A submachine is an instance of a composite state and can
+ be found several times in a same state machine.</p></li><li class="listitem"><p>orthogonal regions: (logically) parallel flow of execution of a state
+ machine. Every region of a state machine gets a chance to process an
+ incoming event.</p></li><li class="listitem"><p>terminate pseudo-state: when this state becomes active, it terminates
+ the execution of the whole state machine.</p></li><li class="listitem"><p>entry/exit pseudo state: defined for composites / submachines and are
+ defined as a connection between a transition outside of the composite
+ and a transition inside the composite. It is a way to enter or leave a
+ submachine through a predefined point.</p></li><li class="listitem"><p>fork: a fork allows explicit entry into several orthogonal regions of
+ a submachine.</p></li><li class="listitem"><p>history: a history is a way to remember the active state of a
+ submachine so that the submachine can proceed in its last state next
+ time it becomes active.</p></li><li class="listitem"><p>completion events (also called completion transitions): when a
+ transition has no named event triggering it, it automatically fires when
+ the source state is active, unless a guard forbids it.</p></li><li class="listitem"><p>transition conflict: a conflict is present if for a given source state
+ and incoming event, several transitions are possible. UML specifies that
+ guard conditions have to solve the conflict.</p></li><li class="listitem"><p>internal transitions: transition from a state to itself without having
+ exit and entry actions being called.</p></li></ul></div><p>
+ </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ar01s02.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ar01s04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Founding idea&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;User's Guide</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ar01s04.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ar01s04.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,1302 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>User's Guide</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="index.html" title="Meta State Machine (MSM)"><link rel="prev" href="ar01s03.html" title="UML Short Guide"><link rel="next" href="ar01s05.html" title="Performance / Compilers"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">User's Guide</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ar01s05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="User's Guide"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e402"></a>User's Guide</h2></div></div></div><div class="sect2" title="Design"><d
iv class="titlepage"><div><div><h3 class="title"><a name="d0e405"></a>Design</h3></div></div></div><p>Msm is divided between front&#8211;ends and back-ends. At the moment, there is just one
+ back-end. On the front-end side, there is more to see. Msm offers several state
+ machine description languages with many more possible. Now, everybody can build his
+ own description language (in case one gets bored with the ones provided) without
+ changes to the library. For who feels like being a language writer this document
+ adds a description of the interface between front-end and back-end.TODO.</p><p>There are, at the moment, three main front-ends. The basic one is an adaptation of
+ the example provided in the MPL book (TODO add link) with actions defined as
+ pointers to state or state machine methods. The second one is based on functors. The
+ third, eUML (embedded UML) is an experimental language based on Boost.Proto and
+ Boost.Typeof and hiding most of the metaprogramming to increase readability. Both
+ eUML and the functor front-end also offer a functional library (a bit like
+ Boost.Phoenix) for use as action language (UML defining none).</p></div><div class="sect2" title="Basic front-end"><div class="titlepage"><div><div><h3 class="title"><a name="d0e412"></a>Basic front-end</h3></div></div></div><p>This is the historical front-end, inherited from the MPL book. It provides a
+ transition table made of rows of different names and functionality. Actions and
+ guards are defined as methods and referenced through a pointer in the transition.
+ This front-end provides a simple interface making easy state machines easier to
+ define, but more complex state machines a bit harder. It also is slightly slower
+ than the functor and eUML front-ends (about 20%). Not that it does more, it simply
+ seems that the compiler better optimizes the functor actions.</p><div class="sect3" title="A simple example"><div class="titlepage"><div><div><h4 class="title"><a name="d0e417"></a>A simple example</h4></div></div></div><p>Let us have a look at a state machine diagram of the founding example:</p><p><span class="inlinemediaobject"><img src="../images/SimpleTutorial.jpg"></span></p><p>We are now going to build it with MSM's basic front-end. An <a class="link" href="examples/SimpleTutorial.cpp" target="_top">example</a> is also
+ provided.</p></div><div class="sect3" title="Transition table"><div class="titlepage"><div><div><h4 class="title"><a name="d0e431"></a>Transition table</h4></div></div></div><p>As previously stated, MSM is based on the transition table, so let us define
+ one:</p><p>struct transition_table : mpl::vector&lt;</p><p>
+ </p><table frame="void" id="d0e440"><tbody><tr>
+ <td>//</td>
+ <td>Start</td>
+ <td>Event</td>
+ <td>Next</td>
+ <td>Action</td>
+ <td>Guard</td>
+ <td> </td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Stopped ,</td>
+ <td>play,</td>
+ <td>Playing,</td>
+ <td>&amp;player_::start_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Stopped ,</td>
+ <td>open_close,</td>
+ <td>Open,</td>
+ <td>&amp;player_::open_drawer</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>_row &lt;</td>
+ <td>Stopped ,</td>
+ <td>stop,</td>
+ <td>Stopped</td>
+ <td> </td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Open ,</td>
+ <td>open_close ,</td>
+ <td>Empty ,</td>
+ <td>&amp;player_::close_drawer</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Empty ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>&amp;player_::open_drawer</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>row &lt;</td>
+ <td>Empty ,</td>
+ <td>cd_detected ,</td>
+ <td>Stopped ,</td>
+ <td>&amp;player_::store_cd_info ,</td>
+ <td>&amp;player_::good_disk_format</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>row &lt;</td>
+ <td>Empty ,</td>
+ <td>cd_detected ,</td>
+ <td>Playing ,</td>
+ <td>&amp;player_::store_cd_info ,</td>
+ <td>&amp;player_::auto_start</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Playing ,</td>
+ <td>stop ,</td>
+ <td>Stopped ,</td>
+ <td>&amp;player_::stop_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Playing ,</td>
+ <td>pause ,</td>
+ <td>Paused ,</td>
+ <td>&amp;player_::pause_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Playing ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>&amp;player_::stop_and_open</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td> Paused ,</td>
+ <td>end_pause ,</td>
+ <td>Playing ,</td>
+ <td>&amp;player_::resume_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td> Paused ,</td>
+ <td>stop ,</td>
+ <td>Stopped ,</td>
+ <td>&amp;player_::stop_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td> Paused ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>&amp;player_::stop_and_open</td>
+ <td> </td>
+ <td>&gt;</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>&gt; {};</td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p>You will notice that this is almost exactly our founding example. The only
+ change in the transition table is the different types of transitions (rows). The
+ founding example forces one to define an action method and offers no guards. You
+ have 4 basic row types:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">row</code> takes 5 arguments: start state, event, next
+ state, action and guard.</p></li><li class="listitem"><p><code class="code">a_row</code> (&#8220;a&#8221; for action) allows defining only the
+ action and omit the guard condition.</p></li><li class="listitem"><p><code class="code">g_row</code> (&#8220;g&#8221; for guard) allows omitting the action
+ method and defining only the guard.</p></li><li class="listitem"><p><code class="code">_row</code> allows omitting action and guard methods.</p></li></ul></div><p>The signature for action methods is:</p><p><code class="code">void stop_playback(stop const&amp;)</code></p><p>Action methods return nothing and take the argument as const reference. Of
+ course nothing forbids you from defining an action for several events:</p><p><code class="code">template &lt;class Event&gt; void stop_playback(Event
+ const&amp;)</code></p><p>Guards have as only difference the return value, which is a boolean:</p><p><code class="code">bool good_disk_format(cd_detected const&amp; evt)</code></p><p>The transition table is actually a MPL vector (or list), which brings a
+ limitation that the default maximum size of the table is 20. If you need more
+ transitions, overriding this default behavior is necessary, for example add
+ before any header:</p><p><code class="code">#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS </code></p><p><code class="code">#define BOOST_MPL_LIMIT_VECTOR_SIZE 30 // or whatever you need
+ </code></p><p><code class="code">#define BOOST_MPL_LIMIT_MAP_SIZE 30 // or whatever you need
+ </code></p><p>The other limitation is that the MPL types are defined only up to 50 entries.
+ For the moment, the only solution to achieve more is to add headers to the MPL
+ (luckily, this is not very complicated).TODO add them</p></div><div class="sect3" title="Defining states with entry/exit actions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e977"></a>Defining states with entry/exit actions</h4></div></div></div><p>While states were enums in the MPL book, they now are structs, which allows
+ them to hold data, provide entry, exit actions, different behaviors and be
+ reusable (as they do not know anything about the containing state machine). To
+ define a state, inherit from the correct state type:</p><p>struct Empty : public msm::front::state&lt;&gt; {};</p><p>They can optionally provide entry and exit behaviors:</p><p><code class="code">struct Empty : public msm::front::state&lt;&gt; {</code></p><p><code class="code">template &lt;class Event, class Fsm&gt; </code></p><p><code class="code">void on_entry(Event const&amp;, Fsm&amp; ) {std::cout &lt;&lt;
+ "entering: Empty" &lt;&lt; std::endl;} </code></p><p><code class="code">template &lt;class Event, class Fsm&gt; </code></p><p><code class="code">void on_exit(Event const&amp;, Fsm&amp; ) {std::cout &lt;&lt; "leaving:
+ Empty" &lt;&lt; std::endl;} </code></p><p><code class="code">};</code></p><p>There are more state types (terminate, interrupt, pseudo states, etc.)
+ corresponding to the UML standard state types. These will be described in
+ details in the next pages.</p></div><div class="sect3" title="Defining a simple state machine"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1006"></a>Defining a simple state machine</h4></div></div></div><p>Declaring a state machine is straightforward and is done with a high signal /
+ noise ratio. In our player example, we declare the state machine as:</p><p><code class="code">struct player_ : public msm::front::state_machine_def&lt;player_&gt;{ /*
+ see below */}</code></p><p>This declares a state machine using the basic front-end. We now declare inside
+ the state machine structure the initial state:</p><p><code class="code">typedef Empty initial_state;</code></p><p>And that is about all of what is absolutely needed. In the example, the states
+ are declared inside the state machine for readability but this is not a
+ requirements, states can be declared wherever you see fit.</p><p>All what is left to us is to pick a back-end (which is quite simple as there
+ is only one at the moment):</p><p><code class="code">typedef msm::back::state_machine&lt;player_&gt; player;</code></p><p>You now have a ready-to-use state machine with entry/exit actions, guards,
+ transition actions, a message queue so that processing an event can generate
+ another event. The state machine also adapted itself to your need and removed
+ almost all features we didn't use in this simple example. Note that this is not
+ per default the faster possible state machine. See the section "getting more
+ speed" to know how to get the maximum speed. In a nutshell, MSM cannot know
+ about your usage of some features so you will have to explicitly tell it.</p><p>TODO no_transition TODO start fct</p></div><div class="sect3" title="Defining a submachine"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1030"></a>Defining a submachine</h4></div></div></div><p>We now want to extend our last state machine by making the Playing state a
+ state machine itself (a submachine).</p><p><span class="inlinemediaobject"><img src="../images/CompositeTutorial.jpg"></span></p><p>Again, an <a class="link" href="examples/CompositeTutorial.cpp" target="_top">example</a> is
+ also provided.</p><p>A submachine really is a state machine itself, so we declare Playing as such,
+ choosing a front-end and a back-end:</p><p><code class="code">struct Playing_ : public msm::Front::state_machine_def&lt;Playing_&gt;{...}
+ </code></p><p><code class="code">typedef msm::back::state_machine&lt;Playing_&gt; Playing;</code></p><p>Like for any state machine, one also needs a transition table and an initial
+ state:</p><p>struct transition_table : mpl::vector&lt;</p><table id="d0e1056"><tbody><tr>
+ <td>//</td>
+ <td>Start</td>
+ <td>Event</td>
+ <td>Next</td>
+ <td>Action</td>
+ <td>Guard</td>
+ <td> </td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>------------------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Song1 ,</td>
+ <td>NextSong,</td>
+ <td>Song2,</td>
+ <td>&amp;Playing_::start_next_song </td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Song2 ,</td>
+ <td>PreviousSong,</td>
+ <td>Song1,</td>
+ <td>&amp;Playing_::start_prev_song </td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Song2 ,</td>
+ <td>NextSong,</td>
+ <td>Song3,</td>
+ <td>&amp;Playing_::start_next_song </td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Song3 ,</td>
+ <td>PreviousSong ,</td>
+ <td>Song2 ,</td>
+ <td>&amp;Playing_::start_prev_song </td>
+ <td> </td>
+ <td>&gt;</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>------------------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>&gt; {};</td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p><code class="code">typedef Song1 initial_state; </code></p><p>This is about all you need to do. MSM will now automatically recognize Playing
+ as a submachine and all events handled by Playing (NextSong and PreviousSong)
+ will now be automatically forwarded to Playing whenever this state is active.
+ All other state machine features described later are also available.</p></div><div class="sect3" title="Orthogonal regions, terminate state, event deferring"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1247"></a>Orthogonal regions, terminate state, event deferring</h4></div></div></div><p>It is a very common problem in many state machines to have to handle errors.
+ It usually involves defining a transition from all the states to a special error
+ state. Translation: not fun. It is also not practical to find from which state
+ the error originated. The following diagram shows an example of what clearly
+ becomes not very readable:</p><p><span class="inlinemediaobject"><img src="../images/error_no_regions.jpg"></span></p><p>This is neither very readable nor beautiful, clearly. And we do not even have
+ any action on the transitions yet.</p><p>Luckily, UML provides a helpful concept, orthogonal regions. See them as
+ lightweight state machines running at the same time in a same state machine and
+ having the capability to influence one another. The effect is that you have
+ several active states at any time. We can therefore keep our state machine from
+ the previous example and just define a new region made of two states, AllOk and
+ ErrorMode. AllOk is most of the time active. But the error_found error event
+ makes the second region move to the new active state ErrorMode. This event does
+ not interest the main region so it will simply be ignored.
+ "<code class="code">no_transition</code>" will be called only if no region at all handles
+ the event. </p><p>Adding an orthogonal region is easy, one only needs to declare more states in
+ the <code class="code">initial_state</code> typedef. So, adding a new region with AllOk as
+ the region's initial state is:</p><p><code class="code">typedef mpl::vector&lt;Empty,AllOk&gt; initial_state;</code></p><p><span class="inlinemediaobject"><img src="../images/Orthogonal-deferred.jpg"></span></p><p>Furthermore, when you detect an error, you usually do not want other events to
+ be handled. To achieve this, we use another UML feature, terminate states. When
+ any region moves to a terminate state, the state machine &#8220;terminates&#8221; (the state
+ machine and all its states stay alive) and all further events are ignored. This
+ is of course not mandatory, one can use orthogonal regions without terminate
+ states. Also note that, as UML mandates, every region gets a chance of handling
+ the event, in the order as declared by the <code class="code">initial_state</code> type. MSM
+ also provides a small extension to UML, interrupt states. If you declare
+ ErrorMode as interrupt state instead of terminate state, the state machine will
+ not handle any event other than the one which ends the interrupt. So it's like a
+ terminate state, with the difference that you are allowed to resume the state
+ machine when a condition (like handling of the original error) is met. </p><p>Last but not least, this example also shows here the handling of event
+ deferring. Let's say someone puts a disc and immediately presses play. The event
+ cannot be handled, yet you'd want it to be handled at a later point and not
+ force the user to press play again. The solution is to define it as deferred in
+ the Empty and Open states and get it handled in the first state where the event
+ is not to be deferred. It can then be handled or rejected. In this example, when
+ Stopped becomes active, the event will be handled because only Empty and Open
+ defer the event.</p><p>Notice how UML defines event deferring as a state property. To accomodate
+ this, MSM lets you specify this in states by providing a
+ <code class="code">deferred_events</code> type:</p><p><code class="code">struct Empty : public msm::front::state&lt;&gt; </code></p><p><code class="code">{ </code></p><p><code class="code">// if the play event is fired while in this state, defer it until a
+ state </code></p><p><code class="code">// handles or rejects it</code></p><p><code class="code"> typedef mpl::vector&lt;play&gt; deferred_events;</code></p><p><code class="code">...};</code></p><p>Please have a look at the <a class="link" href="examples/Orthogonal-deferred.cpp" target="_top">complete example</a>.</p><p>While this is wanted by UML and is simple, it is not always practical because
+ one could wish to defer only in certain conditions. One could also want to make
+ this be part of a transition action with the added bonus of a guard. It would
+ also be conform to the MSM philosophy to get as much as possible in the
+ transition table, where you can have all the important state machine structure
+ grouped together. This is also possible but not practical with this front-end so
+ we will need to pick a different row from the functor front-end. For a complete
+ description of the <code class="code">Row</code> type, please have a look at the <span class="command"><strong><a class="command" href="ar01s04.html#functor-front-end">functor front-end.</a></strong></span></p><p>First, as there is no state where MSM can detect the requirement of this
+ feature, we need to require deferred events capability explicitly, by adding a
+ type in the state machine definition:</p><p><code class="code">struct player_ : public
+ msm::front::state_machine_def&lt;player_&gt;</code></p><p><code class="code">{ </code></p><p><code class="code">typedef int activate_deferred_events;</code></p><p><code class="code">...};</code></p><p>We can now defer an event in any transition of the transition table by using
+ as action the predefined <code class="code">msm::front::Defer</code> functor, for
+ example:</p><p><code class="code">Row &lt; Empty , play , none , Defer , none &gt;</code></p><p>This is an internal transition row(see <span class="command"><strong><a class="command" href="ar01s04.html#internal-transitions">internal transitions</a></strong></span>) but you
+ can ignore this for the moment. It just means that we are not leaving the Empty
+ state. What matters is that we use Defer as action. This is roughly equivalent
+ to the previous syntax but has the advantage of giving you all the information
+ in the transition table.</p><p>The second difference is that as we now have a transition defined, this
+ transition can play in the resolution of <span class="command"><strong><a class="command" href="ar01s03.html#transition-conflict">transition conflicts</a></strong></span>. For
+ example, we could model an "if (condition2) move to Playing else if (condition1)
+ defer play event":</p><p>
+ <code class="code">Row &lt; Empty , play , none , Defer , condition1 &gt;,</code></p><p><code class="code">g_row &lt; Empty , play , Playing , &amp;player_::condition2
+ &gt;</code></p><p>Please have a look at <a class="link" href="examples/Orthogonal-deferred2.cpp" target="_top">this possible implementation</a>.</p></div><div class="sect3" title="History"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1361"></a>History</h4></div></div></div><p>UML defines two types of history, Shallow History and Deep History. What is it
+ and when do you need it? In the previous examples, if the player was playing the
+ second song and the user pressed pause, leaving Playing, at the next press on
+ the play button, the Playing state would become active and the first song would
+ play again. Soon would the first client complaints follow. They'd of course
+ demand, that if the player was paused, then it should remember which song was
+ playing. But it the player was stopped, then it should restart from the first
+ song. Now, how can it be done? Of course, you could add a bit of programming
+ logic and generate extra events to make the second song start if coming from
+ Pause. Something like: </p><p><code class="code">if (Event == end_pause) { for (int i=0;i&lt; song number;++i) {
+ player.process_event(NextSong()); } } </code></p><p>Not much to like in this example, isn't it? To solve this problem, you define
+ what is called a shallow or a deep history. A shallow history reactivates the
+ last active state of a submachine when this state machine becomes active again.
+ The deep history does the same recursively, so if this last active state of the
+ submachine was itself a submachine, its last active state would become active
+ and this will continue until an active state is a normal state. For example, let
+ us have a look at the following UML diagram: </p><p><span class="inlinemediaobject"><img src="../images/HistoryTutorial.jpg"></span></p><p>Notice that the main difference compared to previous diagrams is that the
+ initial state is gone and replaced by a History symbol (the H inside a
+ circle).</p><p>As explained in the <span class="command"><strong><a class="command" href="ar01s03.html#uml-history">small UML
+ tutorial</a></strong></span>, History is a good concept with a not completely
+ satisfying specification. MSM kept the concept but not the specification. Msm
+ goes another way and makes this a policy so you can define your own history
+ types. Furthermore, History is a backend policy. This allows you to reuse the
+ same state machine frontend with different history policies.</p><p>Concretely, your frontend stays unchanged:</p><p><code class="code">struct Playing_ : public
+ msm::front::state_machine_def&lt;Playing_&gt;</code></p><p>You then add the policy to the backend:</p><p><code class="code">typedef
+ msm::back::state_machine&lt;Playing_,msm::back::ShallowHistory&lt;mpl::vector&lt;end_pause&gt;
+ &gt; &gt; Playing;</code></p><p>This states that a shallow history must be activated if the Playing state
+ machine gets activated by the end_pause event and only this one (or any other
+ event added to the mpl::vector). If the state machine was in the Stopped state
+ and the event play was generated, the history would not be activated and the
+ normal initial state would become active. By default, history is disabled. For
+ your convenience the library provides in addition to ShallowHistory a non-UML
+ standard AlwaysHistory policy (likely to be your main choice) which always
+ activates history, whatever event triggers the submachine activation. Deep
+ history is not directly available. The reason is that it would conflict with
+ policies which submachines could define. Of course, if for example, Song1 were a
+ state machine itself, it could use the ShallowHistory policy itself thus
+ creating Deep History. </p></div><div class="sect3" title="Anonymous transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1394"></a>Anonymous transitions</h4></div></div></div><p><span class="command"><strong><a name="anonymous-transitions"></a></strong></span>The following diagram shows an
+ example making use of this feature:</p><p><span class="inlinemediaobject"><img src="../images/Anonymous.jpg"></span></p><p>Anonymous transitions are transitions without a named event. This means that
+ the transition automatically fires when the predecessor state is entered (to be
+ exact, after the entry action). Otherwise it is a normal transition with actions
+ and guards. Why would you need something like that? A possible case would be if
+ a part of your state machine implements some algorithm, where states are steps
+ of the algorithm implementation. Then, using several anonymous transitions with
+ different guard conditions, you are actually implementing some if/else
+ statement. Another possible use would be a real-time system called at regular
+ intervals and always doing the same thing, meaning implementing the same
+ algorithm. The advantage is that once you know how long a transition takes to
+ execute on the system, by calculating the longest path (the number of
+ transitions from start to end), you can pretty much know how long your algorithm
+ will take in the worst case, which in turns tells you how big of a time frame
+ you are to request from a scheduler. </p><p>If you are using Executable UML (a good book describing it is "Executable UML,
+ a foundation for Model-Driven Architecture"), you will notice that it is common
+ for a state machine to generate an event to itself only to leave a state.
+ Anonymous transitions free you from this constraint.</p><p>If you do not use this feature in a concrete state machine, MSM will
+ deactivate it and you will not pay for it. If you use it, there is however a
+ small performance penalty as MSM will try to fire a compound event (the other
+ UML name for anonymous transitions) after every taken transition. This will
+ therefore double the event processing cost, which is not as bad as it sounds as
+ MSM&#8217;s execution speed is very high anyway.</p><p>To define such a transition, use &#8220;none&#8221; as event in the transition table, for
+ example:</p><p><code class="code">row &lt; State3 , none , State4 , &amp;p::State3ToState4 ,
+ &amp;p::always_true &gt;</code></p><p><a class="link" href="examples/AnonymousTutorial.cpp" target="_top">An implementation</a> of
+ the state machine diagram is also provided.</p></div><div class="sect3" title="Internal transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1419"></a><span class="command"><strong><a name="internal-transitions"></a></strong></span>Internal transitions</h4></div></div></div><p>Internal transitions are transitions executing in the scope of the active
+ state, being a simple state or a submachine. One can see them as a
+ self-transition of this state, without an entry or exit action called. This is
+ useful when all you want is to execute some code for a given event in a given
+ state.</p><p>Internal transitions are specified as having a higher priority than normal
+ transitions. While it makes sense for a submachine with exit points, it is
+ surprising for a simple state. MSM lets you define the transition priority by
+ setting the transition&#8217;s position inside the transition table (see <span class="command"><strong><a class="command" href="ar01s07.html#run-to-completion">internals</a></strong></span> ). The difference
+ between "normal" and internal transitions is that internal transitions have no
+ target state, therefore we need new row types. We had a_row, g_row, _row and
+ row, we now add a_irow, g_irow, _irow and irow which are like normal transitions
+ but define no target state. For, example an internal transition with a guard
+ condition could be:</p><p><code class="code">g_irow &lt; Empty /*state*/ , cd_detected
+ /*event*/,&amp;p::internal_guard /* guard */ &gt;</code></p><p>These new row types can be placed anywhere in the transition table so that you
+ can still have your state machine structure grouped together. The only
+ difference of behavior with the UML standard is the missing notion of priority.
+ Please have a look at <a class="link" href="examples/SimpleTutorialInternal.cpp" target="_top">the
+ example</a>.</p><p>It is also possible to do it the UML-conform way by declaring a transition
+ table called <code class="code">internal transition_table</code> inside the state itself and
+ using internal row types. For example:</p><p><code class="code">struct Empty : public msm::front::state&lt;&gt; {</code></p><p><code class="code">struct internal_transition_table : mpl::vector&lt;</code></p><p><code class="code">a_internal &lt; cd_detected , Empty, &amp;Empty::internal_action
+ &gt;</code></p><p><code class="code">&gt; {};</code></p><p><code class="code">};</code></p><p>This declares an internal transition table called internal_transition_table
+ and reacting on the event cd_detected by calling internal_action on Empty. Let
+ us note a few points:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>internal tables are NOT called transition_table but
+ internal_transition_table</p></li><li class="listitem"><p>they use different but similar row types: a_internal, g_internal,
+ _internal and internal.</p></li><li class="listitem"><p>These types take as first template argument the triggering event
+ and then the action and guard method. Note that the only real
+ difference to classical rows is the extra argument before the
+ function pointer. This is the type on which the function will be
+ called.</p></li><li class="listitem"><p>This also allows you, if you wish, to define actions and guards in
+ another state of the state machine or in the state machine
+ itself.</p></li><li class="listitem"><p>submachines can have an internal transition table and a classical
+ transition table.</p></li></ul></div><p>The <a class="link" href="examples/TestInternal.cpp" target="_top">following example</a>
+ makes use of an a_internal. It also uses functor-based internal transitions
+ which will be explained in <span class="command"><strong><a class="command" href="ar01s04.html#functor-internal-transitions">the functor front-end</a></strong></span>, please ignore them for the moment. Also
+ note that the state-defined internal transitions, having following the UML
+ standard the highest priority, are tried before those defined inside the state
+ machine transition table.</p><p>Which method should you use? It depends on what you need:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>the first version (using irow) is simpler and likely to compile
+ faster. It also lets you choose the priority of your internal
+ transition.</p></li><li class="listitem"><p>the second version is more logical from a UML perspective and lets
+ you make states more useful and reusable. It also allows you to call
+ actions and guards on any state of the state machine</p></li></ul></div><p>
+ <span class="command"><strong><a name="internal-transitions-note"></a></strong></span><span class="underline"><span class="bold"><strong>Note</strong></span></span>: There is an added
+ possibility coming from this feature. The <code class="code">internal_transition_table</code>
+ transitions being added directly inside the main state machine's transition
+ table, it is possible, if it is more to your state, to distribute your state
+ machine definition a bit like Boost.Statechart, leaving the state machine itself
+ the only task of declaring the states it wants to use using the
+ <code class="code">explicit_creation</code> type definition. While this is not the
+ author's favorite way, it is still possible. A simplified example using only two
+ states will make it clearer:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><a class="link" href="examples/distributed_table/DistributedTable.cpp" target="_top">state machine definition</a></p></li><li class="listitem"><p>Empty <a class="link" href="examples/distributed_table/Empty.hpp" target="_top">header</a> and <a class="link" href="examples/distributed_table/Empty.cpp" target="_top">cpp</a></p></li><li class="listitem"><p>Open <a class="link" href="examples/distributed_table/Open.hpp" target="_top">header</a> and <a class="link" href="examples/distributed_table/Open.cpp" target="_top">cpp</a></p></li><li class="listitem"><p><a class="link" href="examples/distributed_table/Events.hpp" target="_top">events
+ definition</a></p></li></ul></div><p>There is an added bonus offered for submachines, which can have both the
+ standard transition_table and an internal_transition_table (which has higher
+ priority). This makes it easier if you decide to make a full submachine from a
+ state. It is also slightly faster than the standard alternative, adding
+ orthogonal regions, because event dispatching will, if accepted by the internal
+ table, not continue to the subregions. This gives you a O(1) dispatch instead of
+ O(number of regions). While the example is with eUML, the same is also possible
+ with this front-end.</p></div><div class="sect3" title="more row types"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1532"></a>more row types</h4></div></div></div><p>It is also possible to write transitions using actions and guard conditions
+ not just from the state machine but also from its contained states. In this
+ case, one must specify not just a method pointer but also the object on which to
+ call it. This transition row is called, not very originally, <code class="code">row2</code>.
+ They come, like normal transitions in four flavors: <code class="code">a_row2, g_row2, _row2
+ and row2</code>. For example, a transition calling an action from the state
+ Empty could be:</p><p><code class="code">a_row2 &lt; Stopped , open_close , Open , Empty /*action source*/ ,
+ &amp;Empty::open_drawer /*action*/&gt;</code></p><p>The same capabilities are also available for internal transitions so that we
+ have: <code class="code">a_irow2, g_irow2, _irow2 and row2</code>. For transitions defined as
+ part of the <code class="code">internal_transition_table</code>, you can use the <span class="command"><strong><a class="command" href="ar01s04.html#internal-transitions">a_internal, g_internal, _internal,
+ internal</a></strong></span> row types.</p><p>These row types allow us to distribute the state machine code among states,
+ making them reusable and more valuable. Using transition tables inside states
+ also contributes to this possibility. An <a class="link" href="examples/SimpleTutorial2.cpp" target="_top">example</a> of these new tows
+ is also provided.</p></div><div class="sect3" title="Explicit entry / entry and exit pseudo-state / fork"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1562"></a>Explicit entry / entry and exit pseudo-state / fork</h4></div></div></div><p>MSM (almost) fully supports these features described in the <span class="command"><strong><a class="command" href="ar01s03.html#uml-history">small UML tutorial</a></strong></span>. Almost because there
+ are currently two limitations: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>it is only possible to explicitly enter a sub- state of the target
+ but not a sub-sub state.</p></li><li class="listitem"><p>it is not possible to explicitly exit. Exit points must be
+ used.</p></li></ul></div><p>Let us see a concrete example:</p><p><span class="inlinemediaobject"><img src="../images/entry%20tutorial.jpg"></span></p><p>We find in this diagram:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>A &#8220;normal&#8221; entering into SubFsm2 triggered by event1 and back to
+ State1 using the same event. In each zone is the initial state
+ activated, i.e. SubState1 and SubState1b.</p></li><li class="listitem"><p>An explicit entry into SubFsm2::SubState2 for zone &#8220;a&#8221; with event2
+ as trigger, meaning that in region &#8220;b&#8221; the initial state,
+ SubState1b, activated.</p></li><li class="listitem"><p>A fork into zones &#8220;a&#8221; and &#8220;b&#8221; to the explicit entries SubState2
+ and SubState2b, triggered by event3. Both states become active so no
+ zone is default activated (if we had a third zone, it would
+ be).</p></li><li class="listitem"><p>A connection of two transitions through an entry pseudo state,
+ SubFsm2::PseudoEntry1, triggered by event4 and triggering also the
+ second transition on the same event (both transitions must be
+ triggered by the same event). Zone &#8220;b&#8221; gets default-activated and
+ SubState1b becomes active.</p></li><li class="listitem"><p>An exit from SubFsm2 using an exit pseudo-state, PseudoExit1,
+ triggered by event5 and connecting two transitions using the same
+ event. Again, the event is forwarded to the second transition and
+ both regions are exited, as SubFsm2 becomes inactive. Note that if
+ no transition is defined from PseudoExit1, an error (as defined in
+ the UML standard) will be detected and no_transition called.</p></li></ul></div><p>The example is also <a class="link" href="examples/DirectEntryTutorial.cpp" target="_top">fully
+ implemented</a>.</p><p>This sounds complicated but the syntax is simple.</p><div class="sect4" title="Explicit entry"><div class="titlepage"><div><div><h5 class="title"><a name="d0e1608"></a>Explicit entry</h5></div></div></div><p>First, to define that a state is an explicit entry, you have to make it a
+ state and mark it as explicit, giving as template parameters the zone id
+ (the zone id starts with 0 and corresponds to the first initial state of the
+ initial_state type sequence).</p><p><code class="code">struct SubState2 : public msm::front::state&lt;&gt; , public
+ msm::front::explicit_entry&lt;0&gt;</code></p><p>And define the submachine as:</p><p><code class="code">typedef msm::back::state_machine&lt;SubFsm2_&gt; SubFsm2;</code></p><p>You can then use it as target in a transition with State1 as
+ source:</p><p><code class="code">_row &lt; State1, Event2, SubFsm2::direct&lt; SubFsm2_::SubState2&gt;
+ &gt;</code></p><p>The syntax deserves some explanation. SubFsm2_ is a front end. SubState2
+ is a nested state, therefore the SubFsm2_::SubState2 syntax. The containing
+ machine (containing State1 and SubFsm2) refers to the backend instance
+ (SubFsm2). SubFsm2::direct states that a direct entry is desired.</p><p><span class="underline">Note (also valid for forks)</span>: in
+ order to make compile time more bearable for the more standard cases, and
+ unlike initial states, explicit entry states which are also not found in the
+ transition table of the entered submachine (a rare case) do NOT get
+ automatically created. To explicitly create such states, you need to add in
+ the state machine containing the explicit states a simple typedef giving a
+ sequence of states to be explicitly created like:</p><p><code class="code">typedef mpl::vector&lt;SubState2,SubState2b&gt;
+ explicit_creation;</code></p></div><div class="sect4" title="Fork"><div class="titlepage"><div><div><h5 class="title"><a name="d0e1635"></a>Fork</h5></div></div></div><p>Need a fork instead of an explicit entry? Then, as a fork is an explicit
+ entry into states of different regions, we do not change the state
+ definition compared to the explicit entry and specify as target a list of
+ explicit entry states:</p><p><code class="code">_row &lt; State1, Event3, mpl::vector&lt;SubFsm2::direct&lt;
+ SubFsm2_::SubState2&gt;, SubFsm2::direct &lt;SubFsm2_::SubState2b&gt;
+ &gt;</code></p><p>With SubState2 defined as before and SubState2b defined as being in the
+ second region (Caution: MSM does not check that the region is
+ correct):</p><p><code class="code">struct SubState2b : public msm::front::state&lt;&gt; , public
+ msm::front::explicit_entry&lt;1&gt;</code></p></div><div class="sect4" title="Entry pseudo states"><div class="titlepage"><div><div><h5 class="title"><a name="d0e1648"></a>Entry pseudo states</h5></div></div></div><p> To define an entry pseudo state, you need derive from the corresponding
+ class and give the region id:</p><p><code class="code">struct PseudoEntry1 : public
+ msm::front::entry_pseudo_state&lt;0&gt;</code></p><p>And add the corresponding transition in Fsm's transition table:</p><p><code class="code">_row &lt; State1, Event4,
+ SubFsm2::entry_pt&lt;SubFsm2_::PseudoEntry1&gt; &gt;</code></p><p>And another in the SubFsm2_ submachine definition (remember that UML
+ defines an entry point as a connection between two transitions), for example
+ this time with an action method:</p><p><code class="code">_row &lt; PseudoEntry1, Event4, SubState3,
+ &amp;SubFsm2_::entry_action &gt;</code></p></div><div class="sect4" title="Exit pseudo states"><div class="titlepage"><div><div><h5 class="title"><a name="d0e1666"></a> Exit pseudo states </h5></div></div></div><p>And finally, exit pseudo states are to be used almost the same way, but
+ defined differently: it takes as template argument the event to be forwarded
+ (no region id is necessary):</p><p><code class="code">struct PseudoExit1 : public
+ exit_pseudo_state&lt;event6&gt;</code></p><p>And you need, as for entry pseudo states, two transitions, one in the
+ submachine:</p><p><code class="code">_row &lt; SubState3, Event5, PseudoExit1 &gt;</code></p><p>And one in the containing state machine:</p><p><code class="code">_row &lt; SubFsm2::exit_pt&lt;SubFsm2_::PseudoExit1&gt;, Event6, State2
+ &gt;</code></p><p><span class="underline">Important note 1:</span> UML defines
+ transiting to an entry pseudo state and having either no second transition
+ or one with a guard as an error but defines no error handling. MSM will
+ tolerate this behavior; the entry pseudo state will simply be the newly
+ active state.</p><p><span class="underline">Important note 2</span>: UML defines
+ transiting to an exit pseudo state and having no second transition as an
+ error, and also defines no error handling. Therefore, it was decided to
+ implement exit pseudo state as terminate states and the containing composite
+ not properly exited will stay terminated as it was technically
+ &#8220;exited&#8221;.</p><p><span class="underline">Important note 3:</span> UML states that
+ for the exit point, the same event must be used in both transitions. MSM
+ relaxes this rule and only wants the event on the inside transition to be
+ convertible to the one of the outside transition. In our case, event6 is
+ convertible from event5. Notice that the forwarded event must be named in
+ the exit point definition. For example, we could define event6 as simply
+ as:</p><p><code class="code">struct event6 { event6(){} template &lt;class Event&gt; event6(Event
+ const&amp;){} };//convertible from any event</code>
+ </p></div></div><div class="sect3" title="Flags"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1700"></a>Flags</h4></div></div></div><p>This <a class="link" href="examples/Flags.cpp" target="_top">tutorial</a> is devoted to a
+ concept not defined in UML: flags. It has been added into MSM after proving
+ itself useful on many occasions. Please, do not be frightened as we are not
+ talking about ugly shortcuts made of an improbable collusion of Booleans.</p><p>If you look into the Boost.Statechart documentation you'll find some code
+ like:</p><p><code class="code">if ( ( state_downcast&lt; const NumLockOff * &gt;() != 0 ) &amp;&amp;
+ </code></p><p><code class="code">( state_downcast&lt; const CapsLockOff * &gt;() != 0 ) &amp;&amp;
+ </code></p><p><code class="code">( state_downcast&lt; const ScrollLockOff * &gt;() != 0 ) ) </code></p><p>While correct and found in many UML books, this can be error-prone and a
+ potential time-bomb when your state machine grows and you add new states or
+ orthogonal regions.</p><p>And most of all, it hides the real question, which would be &#8220;does my state
+ machine's current state define a special property&#8221;? In this special case &#8220;are my
+ keys in a lock state&#8221;? So let's apply the Fundamental Theorem of Software
+ Engineering and move one level of abstraction higher.</p><p>In our player example, let's say we need to know if the player has a loaded
+ CD. We could do the same:</p><p><code class="code">if ( ( state_downcast&lt; const Stopped * &gt;() != 0 ) &amp;&amp;
+ </code></p><p><code class="code">( state_downcast&lt; const Open * &gt;() != 0 ) &amp;&amp; </code></p><p><code class="code">( state_downcast&lt; const Paused * &gt;() != 0 ) &amp;&amp;</code></p><p><code class="code">( state_downcast&lt; const Playing * &gt;() != 0 )</code></p><p><code class="code"> ) </code></p><p>Or flag these 4 states as CDLoaded-able. You add a flag_list type into each
+ flagged state:</p><p><code class="code">typedef mpl::vector1&lt;CDLoaded&gt; flag_list;</code></p><p>You can even define a list of flags, for example in Playing:</p><p><code class="code">typedef mpl::vector2&lt;PlayingPaused,CDLoaded&gt; flag_list;</code></p><p>This means that Playing supports both properties. Now to check if your player
+ has a loaded CD, check if your flag is active in the current state:</p><p><code class="code">player p; if (p.is_flag_active&lt;CDLoaded&gt;()) ... </code></p><p>And what if you have orthogonal regions? How to decide if a state machine is
+ in a flagged state? By default, you keep the same code and the current states
+ will be OR'ed, meaning if one of the active states has the flag, then
+ is_flag_active returns true. Of course, in some cases, you might want that all
+ of the active states are flagged for the state to be active. You can also AND
+ the active states:</p><p><code class="code">if (p.is_flag_active&lt;CDLoaded,player::Flag_AND&gt;()) ...</code></p><p>The following diagram displays the flag situation in the tutorial.</p><p><span class="inlinemediaobject"><img src="../images/FlagsTutorial.jpg"></span></p></div><div class="sect3" title="Event Hierarchy"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1766"></a>Event Hierarchy</h4></div></div></div><p>There are cases where transitions with many related but different events are
+ needed. An example is text parsing. Let's say you want to parse a string and use
+ a state machine to handle you parsing state. You want to parse 4 digits and
+ decide to use a state for every matched digit. Your state machine could look
+ like:</p><p><span class="inlinemediaobject"><img src="../images/ParsingDigits.jpg"></span></p><p>But how to detect the digit event? We would like to avoid having to define 10
+ transitions on char_0, char_1... between two states as it would force us to
+ write 4 x 10 transitions and the compile-time would suffer. To solve this
+ problem, MSM supports the triggering of a transition on a subclass event. For
+ example, if we define digits as: </p><p><code class="code">struct digit {};</code></p><p><code class="code">struct char_0 : public digit {}; </code></p><p>And to the same for other digits, we can now fire char_0, char_1 events and
+ this will cause a transition with "digit" as trigger to be taken.</p><p>An example with performance measurement, taken from the documentation of
+ Boost.Xpressive illustrates this example (TODO). You might notice that the
+ performance is actually very good (better).</p></div><div class="sect3" title="Containing state machine (deprecated)"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1787"></a> Containing state machine (deprecated)</h4></div></div></div><p>This feature is still supported in MSM for backward compatibility but made
+ obsolete by the fact that every guard/action/entry action/exit action get the
+ state machine passed as argument and might be removed at a later time.</p><p>All of the states defined in the state machine are created upon state machine
+ construction. This has the huge advantage of a reduced syntactic noise. The cost
+ is a small loss of control of the user on the state creation and access. But
+ sometimes you needed a way for a state to get access to its containing state
+ machine. Basically, a state needs to change its declaration to:</p><p><code class="code">struct Stopped : public msm::front::state&lt;sm_ptr&gt;</code></p><p>And to provide a set_sm_ptr function: <code class="code">void set_sm_ptr(player*
+ pl)</code></p><p>to get a pointer to the containing state machine. The same applies to
+ terminate_state / interrupt_state and entry_pseudo_state / exit_pseudo_state.
+ </p></div></div><div class="sect2" title="Functor front-end"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1803"></a><span class="command"><strong><a name="functor-front-end"></a></strong></span>Functor front-end</h3></div></div></div><p>The functor front-end is the preferred front-end at the moment. It is more
+ powerful than the standard front-end, slightly faster and has a more readable
+ transition table. It also makes it easier to reuse parts of state machines. Like
+ <span class="command"><strong><a class="command" href="ar01s04.html#eUML-front-end">eUML</a></strong></span>, il also comes with a good
+ deal of predefined actions. Actually, eUML generates a functor front-end through
+ Boost.Typeof and Boost.Proto so both offer the same functionality.</p><p>The rows which MSM offers come in different flavors. We saw the a_row, g_row,
+ _row, row, not counting internal rows. This is already much to know, so why define
+ new rows? These types have some disadvantages: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>They are more typing and information than we would wish. This means
+ syntactic noise.</p></li><li class="listitem"><p>Function pointers are weird in C++.</p></li><li class="listitem"><p>The action/guard signature is limited and does not allow for more
+ variations of parameters (source state, target state, current state
+ machine, etc.)</p></li><li class="listitem"><p>It is not easy to reuse action code from a state machine to
+ another.</p></li></ul></div><div class="sect3" title="Transition table"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1827"></a> Transition table </h4></div></div></div><p>We can change the definition of the simple tutorial's transition table
+ to:</p><p>
+ </p><table id="d0e1834"><tbody><tr>
+ <td>//</td>
+ <td>Start</td>
+ <td>Event</td>
+ <td>Next</td>
+ <td>Action</td>
+ <td>Guard</td>
+ <td> </td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Stopped ,</td>
+ <td>play,</td>
+ <td>Playing,</td>
+ <td>start_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Stopped ,</td>
+ <td>open_close,</td>
+ <td>Open,</td>
+ <td>open_drawer,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Stopped ,</td>
+ <td>stop,</td>
+ <td>Stopped,</td>
+ <td> </td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Open ,</td>
+ <td>open_close ,</td>
+ <td>Empty ,</td>
+ <td>close_drawer,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Empty ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>open_drawer</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Empty ,</td>
+ <td>cd_detected ,</td>
+ <td>Stopped ,</td>
+ <td>store_cd_info ,</td>
+ <td>good_disk_format</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>g_row &lt;</td>
+ <td>Empty ,</td>
+ <td>cd_detected ,</td>
+ <td>Playing ,</td>
+ <td>store_cd_info ,</td>
+ <td>&amp;player_::auto_start</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Playing ,</td>
+ <td>stop ,</td>
+ <td>Stopped ,</td>
+ <td>stop_playback,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Playing ,</td>
+ <td>pause ,</td>
+ <td>Paused ,</td>
+ <td>pause_playback,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Playing ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>stop_and_open,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td> Paused ,</td>
+ <td>end_pause ,</td>
+ <td>Playing ,</td>
+ <td>resume_playback,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td> Paused ,</td>
+ <td>stop ,</td>
+ <td>Stopped ,</td>
+ <td>stop_playback,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td> Paused ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>stop_and_open,</td>
+ <td> none</td>
+ <td>&gt;</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>&gt; {};</td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p>Transitions are now of type "Row" with exactly 5 template arguments: source
+ state, event, target state, action and guard. Wherever there is nothing (for
+ example actions and guards), write "none". Actions and guards are no more
+ methods but functors getting as arguments the detected event, the state machine,
+ source and target state:</p><p><code class="code">struct store_cd_info { </code></p><p><code class="code">template &lt;class Fsm,class Evt,class SourceState,class TargetState&gt;
+ </code></p><p><code class="code">void operator()(Evt const&amp;, Fsm&amp; fsm, SourceState&amp;,
+ TargetState&amp; ) </code></p><p><code class="code"> {</code></p><p><code class="code"> cout &lt;&lt; "player::store_cd_info" &lt;&lt; endl;
+ fsm.process_event(play()); </code></p><p><code class="code"> } </code></p><p><code class="code">}; </code></p><p>The advantage to functors compared to functions are that they are generic and
+ reusable. They also allow passing more parameters than just events. The guard
+ functors are the same but have an operator() returning a bool.</p><p>It is also possible to mix rows from different front-ends. To show this, a
+ g_row has been left in the transition table. <span class="underline">Note:</span> in case the action functor is used in the transition table
+ of a state machine contained inside a top-level state machine, the &#8220;fsm&#8221;
+ parameter refers to the lowest-level state machine (referencing this action),
+ not the top-level one.</p><p>To illustrate the reusable point, MSM comes with a whole set of predefined
+ functors. Please refer to eUML for the full list (TODO). For example, we are
+ going to replace the first action by an action sequence and the guard by a more
+ complex functor.</p><p>We decide we now want to execute 2 actions in the first transition (Stopped -&gt;
+ Playing). We only need to change the action start_playback to (TODO)
+ <code class="code">ActionSequence_&lt; mpl::vector&lt;some_action, start_playback&gt; &gt;
+ </code> and now will execute some_action and start_playback every time the
+ transition is taken. ActionSequence_ is a functor callinng each element of the
+ mpl::vector in sequence.</p><p>We also want to replace good_disk_format by a condition of the type:
+ &#8220;good_disk_format &amp;&amp; (some_condition || some_other_condition)&#8221;. We can
+ achieve this using And_ and Or_ functors: <code class="code">And_&lt;good_disk_format,Or_&lt;
+ some_condition , some_other_condition&gt;</code>. It even starts looking like
+ functional programming. MSM ships with functors for operators, state machine
+ usage, STL algorithms or container methods.</p></div><div class="sect3" title="Defining states with entry/exit actions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2362"></a>Defining states with entry/exit actions</h4></div></div></div><p>You probably noticed that we just showed a different transition table and that
+ we even mixed rows from different front-ends. This means that you can do this
+ and leave the definitions for states unchanged. Most examples are doing this as
+ it is the simplest solution. You still enjoy the simplicity of the first
+ front-end with the extended power of the new transition types. This <a class="link" href="examples/SimpleWithFunctors.cpp" target="_top">tutorial</a>, adapted from
+ the earlier example does just this.</p><p>Of course, it is also possible to define states where entry and exit actions
+ are also provided as functors as these are generated by eUML and both front-ends
+ are equivalent. For example, we can define a state as:</p><p><code class="code">struct Empty_Entry { </code></p><p><code class="code">template &lt;class Event,class Fsm,class State&gt; </code></p><p><code class="code">void operator()(Event const&amp;,Fsm&amp;,State&amp;) </code></p><p><code class="code"> {</code></p><p><code class="code"> ... </code></p><p><code class="code"> } </code></p><p><code class="code">}; // same for Empty_Exit</code></p><p><code class="code">struct Empty : public
+ msm::front::euml::func_state&lt;Empty_Entry,Empty_Exit&gt;{};</code></p><p>This also means that you can, like in the transition table, write entry / exit
+ actions made of more complicated action combinations. The previous example can
+ therefore <a class="link" href="examples/SimpleWithFunctors2.cpp" target="_top">be
+ rewritten</a>.</p><p>Usually, however, one will probably use the standard state definition as it
+ provides the same capabilities as this front-end state definition, unless one
+ needs some of the shipped predefined functors.</p></div><div class="sect3" title="Defining a simple state machine"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2403"></a>Defining a simple state machine</h4></div></div></div><p>Like states, state machines can be defined using the previous front-end, as
+ the previous example showed, or with the functor front-end, which allows you to
+ define a state machine entry and exit functions as functors, as in <a class="link" href="examples/SimpleWithFunctors2.cpp" target="_top">this example</a>.</p></div><div class="sect3" title="Anonymous transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2411"></a>Anonymous transitions</h4></div></div></div><p>Anonymous (compound) transitions are transition withour a named event, taken
+ automatically. We saw how this front-end uses <code class="code">none</code> when no action
+ or guard is required. We can also use <code class="code">none</code> instead of an event to
+ mark an anonymous transition. For example, the following transition makes an
+ immediate transition from State1 to State2:</p><p>Row &lt; State1 , none , State2 &gt;</p><p>The following transition does the same but calling an action in the
+ process:</p><p>Row &lt; State1 , none , State2 , State1ToState2, none &gt;</p><p>The following diagram shows an example and its <a class="link" href="examples/AnonymousTutorialWithFunctors.cpp" target="_top">implementation</a>:</p><p><span class="inlinemediaobject"><img src="../images/Anonymous.jpg"></span></p></div><div class="sect3" title="Internal transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2437"></a><span class="command"><strong><a name="functor-internal-transitions"></a></strong></span>Internal transitions</h4></div></div></div><p>The <a class="link" href="examples/SimpleTutorialInternalFunctors.cpp" target="_top">following
+ example</a> uses internal transitions with the functor front-end. As for
+ the simple standard front-end, both methods of defining internal transitions are supported:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>defining a <code class="code">Row</code> in the state machine's transition
+ table with <code class="code">none</code> as target state defines an internal
+ transition</p></li><li class="listitem"><p>defining an <code class="code">internal_transition_table</code> made of
+ <code class="code">Internal</code> rows inside a state defines UML-conform
+ internal transitions with higher priority</p></li><li class="listitem"><p>transitions defined inside <code class="code">internal_transition_table</code>
+ require no source state either as the source state is known.</p></li></ul></div><p>Like for the <span class="command"><strong><a class="command" href="ar01s04.html#internal-transitions-note">standard front-end internal transitions</a></strong></span>, internal transition
+ tables are added into the main state machine's table, thus allowing you to
+ distribute the transition table definition and reuse states.</p><p>There is an added bonus offered for submachines, which can have both the
+ standard transition_table and an internal_transition_table (which has higher
+ priority). This makes it easier if you decide to make a full submachine from a
+ state. It is also slightly faster than the standard alternative, adding
+ orthogonal regions, because event dispatching will, if accepted by the internal
+ table, not continue to the subregions. This gives you a O(1) dispatch instead of
+ O(number of regions). While the example is with eUML, the same is also possible
+ with this front-end.</p></div></div><div class="sect2" title="eUML (experimental)"><div class="titlepage"><div><div><h3 class="title"><a name="d0e2477"></a><span class="command"><strong><a name="eUML-front-end"></a></strong></span>eUML (experimental)</h3></div></div></div><p><span class="underline">Important note</span>: eUML requires a compiler
+ supporting the C++0x decltype/typeof feature (from example VC &gt;= 9, g++ &gt;= 4.3. VC8
+ is partially supported). More generally, eUML has experimental status because most
+ compilers will start crashing when a state machine becomes too big. Only g++ 4.3
+ (unfortunately not 4.4 which shows a serious regression) seems perfectly
+ resilient.</p><p>The previous front-ends are simple to write but still force an amount of noise,
+ mostly MPL types, so it would be nice to write code looking like C++ (with a C++
+ action language) directly inside the transition table, like UML designers like to do
+ on their state machine diagrams. This is what eUML is for.</p><p>eUML is a Boost.Proto-based compile-time domain specific embedded language. It
+ provides grammars which allow the definition of actions/guards directly inside the
+ transition table or entry/exit in the state definition. It is defined in the
+ namespace msm::front::euml. There are grammars for actions, guards, flags,
+ attributes, deferred events, initial states.</p><p>It also relies on Boost.Typeof as a wrapper around the new decltype C++0x feature
+ to provide a compile-time evaluation of all the grammars. Unfortunately, all the
+ underlying Boost libraries are not Typeof-enabled, so for the moment, you will need
+ a compiler where Typeof is natively implemented (like VC8-9-10, g++ &gt;= 4.3).</p><p>Examples will be provided in the next paragraphs. You need to include eUML basic
+ features: </p><p><code class="code">#include &lt;msm/front/euml/euml.hpp&gt;</code></p><p>To add STL support (at possible cost of longer compilation times), include: </p><p><code class="code">#include &lt;msm/front/euml/stl.hpp&gt;</code></p><div class="sect3" title="Transition table"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2501"></a>Transition table</h4></div></div></div><p>A transition can be defined using eUML as: </p><p><code class="code">source + event [guard] / action == target</code> or as</p><p><code class="code">target == source + event [guard] / action</code></p><p>The first version looks like a drawn transition in a diagram, the second one
+ seems natural to a C++ developper.</p><p>The simple transition table written with the <span class="command"><strong><a class="command" href="ar01s04.html#functor-front-end">previous front-end</a></strong></span> can now be
+ written as:</p><p>
+ </p><table frame="void" id="d0e2522"><tbody><tr>
+ <td>typedef BOOST_TYPEOF(build_stt((</td>
+ <td> </td>
+ <td> </td>
+ </tr><tr>
+ <td>Stopped +</td>
+ <td>play [DummyGuard] / (TestFct,start_playback)</td>
+ <td>== Playing</td>
+ </tr><tr>
+ <td>Stopped +</td>
+ <td>open_close/ open_drawer</td>
+ <td>== Open</td>
+ </tr><tr>
+ <td>Stopped +</td>
+ <td>stop</td>
+ <td>== Stopped</td>
+ </tr><tr>
+ <td>Open +</td>
+ <td>open_close / close_drawer</td>
+ <td>== Empty</td>
+ </tr><tr>
+ <td>Empty +</td>
+ <td>open_close / open_drawer </td>
+ <td>== Open</td>
+ </tr><tr>
+ <td>Empty +</td>
+ <td>cd_detected [good_disk_format] / store_cd_info </td>
+ <td>== Stopped</td>
+ </tr><tr>
+ <td> ) ) ) transition_table;</td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p>Or, using the alternative notation, it can be:</p><p>
+ </p><table id="d0e2617"><tbody><tr>
+ <td>typedef BOOST_TYPEOF(build_stt((</td>
+ <td> </td>
+ <td> </td>
+ </tr><tr>
+ <td>Playing == </td>
+ <td>Stopped +</td>
+ <td>play [DummyGuard] / (TestFct,start_playback)</td>
+ </tr><tr>
+ <td>Open ==</td>
+ <td>Stopped +</td>
+ <td>open_close/ open_drawer</td>
+ </tr><tr>
+ <td>Stopped ==</td>
+ <td>Stopped +</td>
+ <td>stop</td>
+ </tr><tr>
+ <td>Empty ==</td>
+ <td>Open +</td>
+ <td>open_close / close_drawer</td>
+ </tr><tr>
+ <td>Open ==</td>
+ <td>Empty +</td>
+ <td>open_close / open_drawer</td>
+ </tr><tr>
+ <td>Stopped ==</td>
+ <td>Empty +</td>
+ <td>cd_detected [good_disk_format] / store_cd_info </td>
+ </tr><tr>
+ <td> ) ) ) transition_table;</td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p>The transition table now looks like a list of (readable) rules with little
+ noise.</p><p>UML defines guards between &#8220;[ ]&#8221; and actions after a &#8220;/&#8221;, so this is already
+ more readable for UML designers. UML also allows designers to define several
+ actions sequentially (our previous ActionSequence) separated by a comma. The
+ first transition does just this: two actions separated by a comma and enclosed
+ inside parenthesis to respect C++ operator precedence.</p><p>If this seems to you like it will cost you run-time performance, don't worry,
+ typeof (decltype) only evaluates the build_stt function and no run-time cost
+ occurs. Actually, eUML is only a metaprogramming layer on top of "standard" MSM
+ metaprogramming and this first layer generates the previously-presented <span class="command"><strong><a class="command" href="ar01s04.html#functor-front-end">functor front-end</a></strong></span>.</p><p>UML also allows designers to define more complicated guards, like
+ [good_disk_format &amp;&amp; (some_condition || some_other_condition)]. This was
+ possible with our previously defined functors, but using a complicated template
+ syntax. This syntax is now possible exactly as written, which means without
+ syntactic noise.</p></div><div class="sect3" title="Defining events, actions and states with entry/exit actions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2719"></a>Defining events, actions and states with entry/exit actions</h4></div></div></div><p>Events must be proto-enabled. To achieve this, they must inherit from
+ euml_event:</p><p><code class="code">struct play : euml_event&lt;play&gt;{};</code></p><p>Actions (returning void) and guards (returning a bool) are defined like
+ previous functors, with the difference that they also must be
+ proto-enabled:</p><p><code class="code">struct some_condition : euml_action&lt; some_condition &gt;</code></p><p><code class="code">{ </code></p><p><code class="code">template &lt;class Fsm,class Evt,class SourceState,class
+ TargetState&gt;</code></p><p><code class="code">bool operator()(Evt const&amp; ,Fsm&amp; ,SourceState&amp;
+ ,TargetState&amp; ) { return true; } </code></p><p><code class="code">}; </code></p><p>It is also possible to use the same action grammar as for the transition table
+ for state entry and exit actions:</p><p><code class="code">typedef BOOST_TYPEOF(euml::build_state( (Empty_Entry,Dummy_Entry)/*2
+ entry actions*/,Empty_Exit/*1 exit action*/ )) Empty;</code></p><p>This means that Empty is defined as a state with an entry action made of two
+ sub-actions, Empty_Entry and Dummy_Entry (enclosed inside parenthesis), and an
+ exit action, Empty_Exit.</p><p>There are several overloads of the <span class="command"><strong><a name="eUML-build-state"></a></strong></span>build_state function:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>build_state(): state without entry or exit action.</p></li><li class="listitem"><p>build_state(Expr1): state with entry but no exit action.</p></li><li class="listitem"><p>build_state(Expr1,Expr2): state with entry and exit action.</p></li><li class="listitem"><p>build_state(Expr1,Expr2,Attributes): state with entry and exit
+ action, defining some attributes (read further on).</p></li><li class="listitem"><p>build_state(Expr1,Expr2,Attributes,Configure): state with entry
+ and exit action, defining some attributes (read further on) and
+ flags (standard MSM flags) or deferred events (standard MSM deferred
+ events).</p></li><li class="listitem"><p>build_state(Expr1,Expr2,Attributes,Configure,Base): state with
+ entry and exit action, defining some attributes (read further on),
+ flags and deferred events (plain msm deferred events) and a
+ non-default base state (as defined in standard MSM).</p></li></ul></div><p>A NoAction is also defined, which does, well, nothing except being a
+ placeholder (needed for example as entry action if we have no entry but an
+ exit). Expr1 and Expr2 are a sequence of actions, obeying the same action
+ grammar as in the transition table (following the &#8220;/&#8221; symbol).</p><p>The state functors have a slightly different signature as there is no source
+ and target state but only a current state (entry/exit actions are
+ transition-independent), for example:</p><p><code class="code">struct Empty_Entry : euml_action&lt; Empty_Entry &gt;</code></p><p><code class="code">{ </code></p><p><code class="code">template &lt;class Evt,class Fsm,class State&gt;</code></p><p><code class="code">void operator()(Evt const&amp; ,Fsm&amp; ,State&amp; ) { ... }
+ </code></p><p><code class="code">}; </code></p><p>Notice again the euml_action, to make the functor play nice with the grammar.
+ </p></div><div class="sect3" title="Defining a simple state machine"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2795"></a>Defining a simple state machine</h4></div></div></div><p>Like for a functor front-end, you can reuse the state machine definition
+ method from the standard front-end. You can also use eUML to define a state
+ machine "on the fly" (if, for example, you need to provide an on_entry/on_exit
+ for this state machine as a functor). For this, there is also a function,
+ <span class="command"><strong><a name="eUML-build-sm"></a></strong></span>build_sm, which has up to 8 arguments:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>build_sm(Stt, Init): simplest state machine where only the
+ transition table and initial state(s) are defined.</p></li><li class="listitem"><p>build_sm(Stt, Init, Expr1): state machine where the transition
+ table, initial state and entry action are defined.</p></li><li class="listitem"><p>build_sm(Stt, Init, Expr1, Expr2): state machine where the
+ transition table, initial state, entry and exit actions are
+ defined.</p></li><li class="listitem"><p>build_sm(Stt, Init, Expr1, Expr2, Attributes): state machine where
+ the transition table, initial state, entry and exit actions are
+ defined. Furthermore, some attributes are added (read further
+ on).</p></li><li class="listitem"><p>build_sm(Stt, Init, Expr1, Expr2, Attributes, Configure): state
+ machine where the transition table, initial state, entry and exit
+ actions are defined. Furthermore, some attributes (read further on),
+ flags, deferred events and configuration capabilities TODO link (no
+ message queue / no exception catching) are added.</p></li><li class="listitem"><p>build_sm(Stt, Init, Expr1, Expr2, Attributes, Flags, Deferred ,
+ Base): state machine where the transition table, initial state,
+ entry and exit actions are defined. Furthermore, attributes (read
+ further on), flags , deferred events and configuration capabilities
+ (no message queue / no exception catching) are added and a
+ non-default base state (see base state TODO) is defined.</p></li></ul></div><p>For example, a minimum state machine could be defined
+ like:</p><p>
+ </p><table id="d0e2824"><tbody><tr>
+ <td>typedef BOOST_TYPEOF(build_stt((</td>
+ <td> </td>
+ <td> </td>
+ </tr><tr>
+ <td>... ) ) ) transition_table;</td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p><code class="code">typedef BOOST_TYPEOF(build_sm( transition_table(),init_ &lt;&lt; Empty
+ )) player_;</code></p><p><span class="underline">Note for VC9</span>: This defined build_sm
+ syntax works most of the time. But once in a while, VC9 will display the problem
+ shown in the next section (not enough heap space). For example, this simple
+ performance test (TODO link), while really simple, will display the bug. To
+ correct it, the following solution works: </p><p><code class="code">#ifndef BOOST_MSVC</code></p><p><code class="code">typedef BOOST_TYPEOF(build_sm( transition_table(),init_ &lt;&lt; Empty
+ &lt;&lt; AllOk )) player_;</code></p><p><code class="code">#else</code></p><p><code class="code">struct player_ : public BOOST_TYPEOF(build_sm( transition_table(),init_
+ &lt;&lt; Empty &lt;&lt; AllOk )) {};</code></p><p><code class="code">#endif</code></p><p>Please have a look at the player tutorial written using eUML's <a class="link" href="examples/SimpleTutorialEuml2.cpp" target="_top">first</a> and <a class="link" href="examples/SimpleTutorialEuml.cpp" target="_top">second</a> syntax. Please
+ ignore for the moment the BOOST_MSM_EUML_DECLARE_ATTRIBUTE macros, we come back
+ to it very soon.</p></div><div class="sect3" title="Defining a submachine"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2879"></a>Defining a submachine</h4></div></div></div><p>Defining a submachine (see <a class="link" href="examples/CompositeTutorialEuml.cpp" target="_top">tutorial</a>) with other
+ front-ends simply means using a state which is a state machine in the transition
+ table of another state machine. This is the same with eUML. One only needs
+ define a second state machine and reference it in the transition table of the
+ containing state machine.</p><p><span class="underline">Note</span>: the previous #ifdef trick has to
+ be used for submachine definition because the VC9 bug occurs more often when
+ submachines are involved.</p></div><div class="sect3" title="Attributes / Function call"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2891"></a> Attributes / Function call</h4></div></div></div><p>We now want to make our grammar more useful. Very often, one needs only very
+ simple action methods, for example ++Counter or Counter &gt; 5 where Counter is
+ usually defined as some attribute of the class containing the state machine.
+ Furthermore, unlike many expensive tools which are on the market, states within
+ MSM are also classes so they can have attributes, and we would also like to
+ provide them with attributes. </p><p>If you look back at our examples using the <a class="link" href="examples/SimpleTutorialEuml2.cpp" target="_top">first</a> and <a class="link" href="examples/SimpleTutorialEuml.cpp" target="_top">second</a> syntaxes, you
+ will find some unexplained BOOST_MSM_EUML_DECLARE_ATTRIBUTE macros. Let us go
+ back to them. We have:</p><p><code class="code">BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,cd_name)</code></p><p><code class="code">BOOST_MSM_EUML_DECLARE_ATTRIBUTE(DiskTypeEnum,cd_type)</code></p><p>This declares two attributes: cd_name of type std::string and cd_type of type
+ DiskTypeEnum. These attributes are not part of any event or state in particular,
+ we just declared a name and a type. Now, we can add attributes to our
+ cd_detected event:</p><p><code class="code">typedef BOOST_TYPEOF(build_attributes(attributes_ &lt;&lt; cd_name
+ &lt;&lt; cd_type )) cd_detected_attributes;</code></p><p><code class="code">struct cd_detected : euml_event&lt;cd_detected&gt;,cd_detected_attributes
+ {</code></p><p><code class="code">cd_detected(std::string name, DiskTypeEnum diskType) {</code></p><p><code class="code">get_attribute(cd_name)=name;get_attribute(cd_type)=diskType;}</code></p><p><code class="code">};</code></p><p>The two left shift of the first line add both attributes into the helper
+ cd_detected_attributes structure. As cd_detected inherits from the helper, it
+ now has these two attributes. The function get_attribute returns a reference to
+ the required attributes so that we can easily write and set them.</p><p>Ok, great, we now have a two liner to add attributes to a class, which we
+ could have done more easily, so what is the point? The point is that we can now
+ do what was not possible, reference these attributes directly, at compile-time,
+ in the transition table. For example, in the example, you will find this
+ transition:</p><p><code class="code">Stopped == Empty + cd_detected [good_disk_format &amp;&amp;
+ (event_(cd_type)==Int_&lt;DISK_CD&gt;())] </code></p><p>Read event_(cd_type) as event_-&gt;cd_type with event_ a type generic for events,
+ whatever the concrete event is (in this particular case, it happens to be a
+ cd_detected as the transition shows).</p><p>The main advantage of this feature is that you do not need to define a new
+ functor and you do not need to look inside the functor to know what it does, you
+ have all at hand.</p><p>MSM provides more generic objects for state machine types:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>event_ : used inside any action, the event triggering the
+ transition</p></li><li class="listitem"><p>state_: used inside entry and exit actions, the entered / exited
+ state</p></li><li class="listitem"><p>source_: used inside a transition action, the source state</p></li><li class="listitem"><p>target_: used inside a transition action, the target state</p></li><li class="listitem"><p>fsm_: used inside any action, the (lowest-level) state machine
+ processing the transition</p></li><li class="listitem"><p>Int_&lt;int value&gt;: a functor representing an int</p></li><li class="listitem"><p>Char_&lt;value&gt;: a functor representing a char</p></li><li class="listitem"><p>Size_t_&lt;value&gt;: a functor representing a size_t</p></li><li class="listitem"><p>String_&lt;mpl::string&gt; (boost &gt;= 1.40): a functor representing a
+ string.</p></li></ul></div><p>These helpers can be used in two different ways:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>helper(attribute_name) returns the attribute with name
+ attribute_name</p></li><li class="listitem"><p>helper returns the state / event type itself.</p></li></ul></div><p>The second form is helpful if you want to use states with self-created
+ functors. In the <a class="link" href="examples/SimpleTutorialEuml.cpp" target="_top">above
+ tutorial</a>, we provide Empty with an activate_empty method. We would
+ like to create a eUML functor and call it from inside the transition table. This
+ is done using the MSM_EUML_METHOD / MSM_EUML_FUNCTION macros. The first creates
+ a functor to a method, the second to a free function. In the tutorial, we
+ write:</p><p><code class="code">MSM_EUML_METHOD(ActivateEmpty_ , activate_empty , activate_empty_ , void
+ , void )</code></p><p>The first parameter is the functor name, for use either directly or with the
+ functor front-end. The second is the name of the method which will be called.
+ The third is the function name for use in the transition table, the fourth is
+ the return type of the function if used in the context of a transition action,
+ the fifth is the result type if used in the context of a state entry / exit
+ action (usually fourth and fifth are the same). We now have a new eUML function
+ calling a method of "something", and this "something" is one of the five
+ previously explained helpers. We can now use this in a transition, for
+ example:</p><p><code class="code">Empty == Open + open_close /
+ (close_drawer,activate_empty_(target_))</code></p><p>The action is now defined as a sequence of two actions: close_drawer and
+ activate_empty called on the target itself. The target being Empty (the state
+ defined left), this really will call Empty.activate_empty(). This method could
+ also have an (or several) argument(s), for example the event, we could then call
+ activate_empty_(target_ , event_).</p><p>More examples can be found in the <a class="link" href="examples/CompilerStressTestEuml.cpp" target="_top">terrible compiler stress
+ test</a>, the <a class="link" href="examples/SimpleTimer.cpp" target="_top">timer
+ example</a> or in the <a class="link" href="examples/iPodSearchEuml.cpp" target="_top">iPodSearch with eUML</a> (for String_ and more).</p></div><div class="sect3" title="Orthogonal regions, flags, event deferring"><div class="titlepage"><div><div><h4 class="title"><a name="d0e3003"></a>Orthogonal regions, flags, event deferring</h4></div></div></div><p>To define orthogonal regions really means defining more initial states. To add
+ more initial states, &#8220;shift left&#8221; some, for example, if we had another initial
+ state named AllOk :</p><p><code class="code">typedef BOOST_TYPEOF(build_sm( transition_table(),init_ &lt;&lt; Empty
+ &lt;&lt; AllOk )) player_;</code></p><p>You remember from the <span class="command"><strong><a class="command" href="ar01s04.html#eUML-build-state">build_state</a></strong></span> and <span class="command"><strong><a class="command" href="ar01s04.html#eUML-build-sm">build_sm</a></strong></span> signatures that just after attributes, we can define
+ flags, like in the basic MSM frontend. To do this, we have another "shift-left"
+ grammar, for example:</p><p><code class="code">typedef BOOST_TYPEOF(build_state(NoAction,NoAction, attributes_ &lt;&lt;
+ no_attributes_, </code></p><p><code class="code">/* flags */ configure_&lt;&lt; PlayingPaused &lt;&lt; CDLoaded ))
+ Paused; </code></p><p>We now defined that Paused will get two flags, PlayingPaused and CDLoaded,
+ defined, for example as:</p><p><code class="code">struct CDLoaded : euml_flag&lt;CDLoaded&gt; {};</code></p><p>This corresponds to the following basic front-end definition of Paused:</p><p><code class="code">struct Paused : public msm::front::state&lt;&gt; </code></p><p><code class="code">{ typedef mpl::vector2&lt;PlayingPaused,CDLoaded&gt; flag_list; };
+ </code></p><p>Under the hood, what you get really is a mpl::vector2.</p><p><span class="underline">Note</span>: As we use the version of
+ build_state with 4 arguments, we need to tell eUML that we need no attributes.
+ Similarly to a <code class="code">cout &lt;&lt; endl</code>, we need a <code class="code">attributes_
+ &lt;&lt; no_attributes_</code> syntax.</p><p>You can use the flag with the is_flag_active method of a state machine. You
+ can also use the provided helper function is_flag_ (returning a bool) for state
+ and transition actions. For example, in the iPod implementation with eUML (TODO
+ link), you find the following transition:</p><p><code class="code">ForwardPressed == NoForward + EastPressed
+ [!is_flag_(NoFastFwd)]</code></p><p>The function also has an optional second parameter which is the state machine
+ on which the function is called. by default, fsm_ is used (the current state
+ machine) but you could provide a functor returning a reference to another state
+ machine.</p><p>eUML also supports defining deferred events in the state (state machine)
+ definition. To this aim, we can reuse the flag grammar. For example:</p><p><code class="code">typedef BOOST_TYPEOF(build_state(Empty_Entry,Empty_Exit, attributes_
+ &lt;&lt; no_attributes_, </code></p><p><code class="code">/* flags */ configure_&lt;&lt; play )) Empty; </code></p><p>The configure_ left shift is also responsible for deferring events. Shit
+ inside a flag and it will be seen as a flag, shift an event and it will be a
+ deferred event. This replaces the basic front-end definition:</p><p><code class="code">typedef mpl::vector&lt;play&gt; deferred_events;</code></p><p>In <a class="link" href="examples/OrthogonalDeferredEuml.cpp" target="_top">this
+ tutorial</a>, player is defining a second orthogonal region with AllOk as
+ initial state. The <code class="code">Empty</code> and <code class="code">Open</code> states also defer
+ the event <code class="code">play</code>. <code class="code">Open</code>, <code class="code">Stopped</code> and
+ <code class="code">Pause</code> also support the flag <code class="code">CDLoaded</code> using the
+ same left shift into <code class="code">configure_</code>.</p><p>In the functor front_end, we also had the possibility to defer an event inside
+ a transition, which makes possible conditional deferring. This is also possible
+ with eUML through the use of the defer_ order, as shown in <a class="link" href="examples/OrthogonalDeferredEuml.cpp" target="_top">this tutorial</a>. You
+ will find the foillowing transition:</p><p><code class="code">Open + play / defer_</code></p><p>This is an <span class="command"><strong><a class="command" href="ar01s04.html#eUML-internal">internal transition</a></strong></span>.
+ Ignore it for the moment. Interesting is, that when the event <code class="code">play</code>
+ is fired and <code class="code">Open</code> is active, the event will be deferred. Now add a
+ guard and you can conditionally defer the event, for example:</p><p><code class="code">Open + play [ some_condition ] / defer_</code></p><p>This is similar to what we did with the functor front-end. This means that we
+ have the same limitations. Using defer_ instead of a state declaration, we need
+ to tell MSM that we have deferred events in this state machine. We do this
+ (again) using a configure_ declaration in the state machine definition in which
+ we shift the deferred_events configuration flag using the build_sm
+ function:</p><p><code class="code">typedef BOOST_TYPEOF(build_sm( transition_table(),init_ &lt;&lt; Empty
+ &lt;&lt; AllOk,</code></p><p><code class="code">Entry_Action, Exit_Action, attributes_ &lt;&lt; no_attributes_,
+ configure_&lt;&lt; deferred_events )) player_;</code></p><p>A <a class="link" href="examples/OrthogonalDeferredEuml2.cpp" target="_top">tutorial</a>
+ illsutrates this possibility.</p></div><div class="sect3" title="Customizing a state machine / Getting more speed"><div class="titlepage"><div><div><h4 class="title"><a name="d0e3134"></a> Customizing a state machine / Getting more speed</h4></div></div></div><p>We just saw how to use configure_ to define deferred events or flags. We can
+ also use it to configure our state machine like we did with other front-ends
+ (TODO add in standard):</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>configure_ &lt;&lt; no_exception: disables exception
+ handling</p></li><li class="listitem"><p>configure_ &lt;&lt; no_msg_queue deactivates the message
+ queue</p></li></ul></div><p>Deactivating these features if not needed greatly improves the event
+ dispatching speed of your state machine. Our <a class="link" href="examples/EumlSimple.cpp" target="_top">speed testing</a> example with eUML
+ use this feature.</p></div><div class="sect3" title="Anonymous transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e3151"></a>Anonymous transitions</h4></div></div></div><p>Anonymous transitions (See <span class="command"><strong><a class="command" href="ar01s03.html#uml-anonymous">UML
+ tutorial</a></strong></span>) are transitions without a named event which are
+ therefore triggered immediately when the source state becomre active, provided a
+ guard allows it. As there is no event, to define such a transition, simply omit
+ the &#8220;+&#8221; part of the transition (the event), for example: </p><p><code class="code">State3 == State4 [always_true] / State3ToState4</code></p><p><code class="code">State4 [always_true] / State3ToState4 == State3</code></p><p>Please have a look at <a class="link" href="examples/AnonymousTutorialEuml.cpp" target="_top">this example</a>, which implements the <span class="command"><strong><a class="command" href="ar01s04.html#anonymous-transitions">previously defined</a></strong></span> state
+ machine with eUML.</p></div><div class="sect3" title="Internal transitions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e3173"></a><span class="command"><strong><a name="eUML-internal"></a></strong></span>Internal transitions</h4></div></div></div><p>Like both other front-ends, eUML supports two ways of defining internal transitions:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>in the state machine's transition table. In this case, you need to
+ specify a source state, event, actions and guards but no target
+ state, which eUML will interpret as an internal transition, for
+ example this defines a transition internal to Open, on the event
+ open_close:</p><p><code class="code">Open + open_close [internal_guard1] /
+ internal_action1</code></p><p><a class="link" href="examples/EumlInternal.cpp" target="_top">A full example</a>
+ is also provided.</p></li><li class="listitem"><p>in a state's <code class="code">internal_transition_table</code>. For
+ example:</p><p><code class="code">typedef BOOST_TYPEOF(build_state( Open_Entry(),Open_Exit()
+ )) Open_def;</code></p><p><code class="code">struct Open : public Open_def {</code></p><p><code class="code">typedef BOOST_TYPEOF(build_internal_stt((</code></p><p><code class="code">open_close [internal_guard1] /
+ internal_action1</code></p><p><code class="code">) ) ) internal_transition_table;</code></p><p><code class="code">};</code></p><p>Notice how we do not need to repeat that the transition originates
+ from Open as we already are in the context of Open. </p><p>The <a class="link" href="examples/EumlInternalDistributed.cpp" target="_top">implementation</a> also shows the added bonus offered for
+ submachines, which can have both the standard transition_table and
+ an internal_transition_table (which has higher priority). This makes
+ it easier if you decide to make a full submachine from a state. It
+ is also slightly faster than the standard alternative, adding
+ orthogonal regions, because event dispatching will, if accepted by
+ the internal table, not continue to the subregions. This gives you a
+ O(1) dispatch instead of O(number of regions).</p></li></ul></div></div><div class="sect3" title="Direct entry / entry and exit pseudo-state / fork"><div class="titlepage"><div><div><h4 class="title"><a name="d0e3221"></a>Direct entry / entry and exit pseudo-state / fork</h4></div></div></div><p>We saw the <span class="command"><strong><a class="command" href="ar01s04.html#eUML-build-state">build_state</a></strong></span>
+ function, which creates a simple state. Likewise, eUML provides other
+ state-building functions for other types of states:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>build_terminal_state takes the same arguments as build_state and
+ defines, well, a terminate state.</p></li><li class="listitem"><p>build_interrupt_state takes the same arguments as build_state and
+ defines an interrupt state.</p></li><li class="listitem"><p>build_exit_state takes the same arguments as build_state and
+ defines an exit pseudo state.</p></li><li class="listitem"><p>build_entry_state takes the same arguments as build_state and
+ defines an interrupt state. The region index to be entered is
+ defined as an int template argument, so build_entry_state&lt;0&gt;
+ defines an entry state into the first region of a submachine.</p></li><li class="listitem"><p>build_explicit_entry_state takes the same arguments as build_state
+ and defines an explicit entry state. The region index to be entered
+ is defined as an int template argument, so
+ build_explicit_entry_state&lt;0&gt; defines an explicit entry state
+ into the first region of a submachine.</p></li></ul></div><p>Using these states in the transition table is like in any other front end
+ using fsm_name::exit_pt&lt;&gt;, fsm_name::direct&lt;&gt; and fsm_name::entry_pt&lt;&gt;.
+ For example, a direct entry could be:</p><p><code class="code">SubFsm2::direct&lt;SubState2&gt; == State1 + event2</code></p><p>Forks being a list on direct entries, eUML supports a logical syntax (state1,
+ state2, ...), for example:</p><p><code class="code">(SubFsm2::direct&lt;SubState2&gt;, SubFsm2::direct&lt;SubState2b&gt;,
+ SubFsm2::direct&lt;SubState2c&gt;) == State1 + event3</code></p><p>The <a class="link" href="examples/DirectEntryEuml.cpp" target="_top">entry tutorial</a> is
+ also available with eUML.</p></div><div class="sect3" title="Helper functions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e3260"></a>Helper functions</h4></div></div></div><p>We saw a few helpers but there are more, so let us have a more complete description:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>event_ : used inside any action, the event triggering the
+ transition</p></li><li class="listitem"><p>state_: used inside entry and exit actions, the entered / exited
+ state</p></li><li class="listitem"><p>source_: used inside a transition action, the source state</p></li><li class="listitem"><p>target_: used inside a transition action, the target state</p></li><li class="listitem"><p>fsm_: used inside any action, the (lowest-level) state machine
+ processing the transition</p></li><li class="listitem"><p>The previous objects can also return an attribute, for example
+ event_(cd_name)</p></li><li class="listitem"><p>Int_&lt;int value&gt;: a functor representing an int</p></li><li class="listitem"><p>Char_&lt;value&gt;: a functor representing a char</p></li><li class="listitem"><p>Size_t_&lt;value&gt;: a functor representing a size_t</p></li><li class="listitem"><p>True_ and False_ functors returning true and false
+ respectively</p></li><li class="listitem"><p>String_&lt;mpl::string&gt; (boost &gt;= 1.40): a functor representing a
+ string.</p></li><li class="listitem"><p>if_then_else_(guard, action, action) where action can be an action
+ sequence</p></li><li class="listitem"><p>if_then_(guard, action) where action can be an action
+ sequence</p></li><li class="listitem"><p>while_(guard, action) where action can be an action
+ sequence</p></li><li class="listitem"><p>do_while_(guard, action) where action can be an action
+ sequence</p></li><li class="listitem"><p>for_(action, guard, action, action) where action can be an action
+ sequence</p></li><li class="listitem"><p>process_(some_event [, some state machine] [, some state machine]
+ [, some state machine] [, some state machine]) will call
+ process_event (some_event) on the current state machine or on the
+ one(s) passed as 2nd , 3rd, 4th, 5th argument. This allow sending
+ events to several external machines</p></li><li class="listitem"><p>process2_(some_event,Value [, some state machine] [, some state
+ machine] [, some state machine]) will call process_event
+ (some_event(Value)) on the current state machine or on the one(s)
+ passed as 3rd, 4th, 5th argument</p></li><li class="listitem"><p>is_ flag_(some_flag[, some state machine]) will call
+ is_flag_active on the current state machine or on the one passed as
+ 2nd argument</p></li><li class="listitem"><p>Predicate_&lt;some predicate&gt;: Used in STL algorithms. Wraps
+ unary/binary functions to make them eUML-compatible so that they can
+ be used in STL algorithms</p></li></ul></div><p>This can make for quite some fun. For example, </p><p><code class="code">/( if_then_else_(--fsm_(m_SongIndex) &gt; Int_&lt;0&gt;(),/*if
+ clause*/</code></p><p><code class="code">show_playing_song(), /*then clause*/</code></p><p><code class="code">(fsm_(m_SongIndex)=Int_&lt;1&gt;(),process_(EndPlay())) /*else clause*/ )
+ )</code> means:</p><p>if (fsm.SongIndex &gt; 0, call show_playing_song else {fsm.SongIndex=1; process
+ EndPlay on fsm;}</p><p>A few examples are using these features:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>the iPod example introduced at the BoostCon09 <a class="link" href="examples/iPodEuml.cpp" target="_top">has been rewritten</a>
+ with eUML (weak compilers please move on...)</p></li><li class="listitem"><p>the iPodSearch example also introduced at the BoostCon09 <a class="link" href="examples/iPodSearchEuml.cpp" target="_top">has been
+ rewritten</a> with eUML. In this example, you will also find
+ some examples of STL functor usage.</p></li><li class="listitem"><p><a class="link" href="examples/SimpleTimer.cpp" target="_top">A simpler timer</a>
+ example is a good starting point. </p></li></ul></div><p>There is unfortunately a small catch. Defining a functor using MSM_EUML_METHOD
+ or MSM_EUML_FUNCTION will create a correct functor. Your own eUML functors
+ written as described at the beginning of this section will also work well,
+ <span class="underline">except</span> with the while_, if_then_,
+ if_then_else_ functions which will require a bit of writing. TODO macro.</p></div><div class="sect3" title="Phoenix-like STL support"><div class="titlepage"><div><div><h4 class="title"><a name="d0e3365"></a>Phoenix-like STL support</h4></div></div></div><p>As we saw, eUML supports most C++ operators (except address-of). For example
+ it is possible to write event_(some_attribute)++ or [source_(some_bool)
+ &amp;&amp; fsm_(some_other_bool)]. But a programmer needs more than operators in
+ his daily programming. The STL is clearly a must have. Therefore, eUML comes in
+ with a lot of functors to simplify your day-to-day programming. For almost every
+ algorithm or container method of the STL, a corresponding eUML function is
+ defined. Like Boost.Phoenix, &#8220;.&#8221; And &#8220;-&gt;&#8221; of call on objects are replaced by a
+ functional programming paradigm, for example:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>begin_(container), end_(container): returns iterators of a
+ container.</p></li><li class="listitem"><p>empty_(container): returns container.empty()</p></li><li class="listitem"><p>clear_(container): container.clear()</p></li><li class="listitem"><p>transform_ : std::transform</p></li></ul></div><p>In a nutshell, almost every STL method or algorithm is matched by a
+ corresponding functor, which can then be used in the transition table or state
+ actions. The reference (TODO link) explains in detail the usage and the
+ underlying functor (so that this possibility is not reserved to eUML but also to
+ the functor-based front-end). The file structure of this Phoenix-like library
+ matches the one of Boost.Phoenix. All STL algorithm functors are to be found
+ in:</p><p><code class="code">#include &lt;msm/front/euml/algorithm.hpp&gt;</code></p><p>The algorithms are also divided into sub-headers, matching the phoenix
+ structure for simplicity:</p><p><code class="code">#include &lt; msm/front/euml/iteration.hpp&gt; </code></p><p><code class="code">#include &lt; msm/front/euml/transformation.hpp&gt; </code></p><p><code class="code">#include &lt; msm/front/euml/querying.hpp&gt; </code></p><p>Container methods can be found in:</p><p><code class="code">#include &lt; msm/front/euml/container.hpp&gt;</code></p><p>Or one can simply include the whole STL support (you will also need to include
+ euml.hpp):</p><p><code class="code">#include &lt; msm/front/euml/stl.hpp&gt;</code></p><p>A few examples (to be found in <a class="link" href="examples/iPodSearchEuml.cpp" target="_top">this tutorial</a>):</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">push_back_(fsm_(m_tgt_container),event_(m_song))</code>: the
+ state machine has an attribute m_tgt_container of type
+ std::vector&lt;OneSong&gt; and the event has an attribute m_song of
+ type OneSong. The line therefore pushes m_song at the end of
+ m_tgt_container</p></li><li class="listitem"><p><code class="code">if_then_( state_(m_src_it) != end_(fsm_(m_src_container)),
+ process2_(OneSong(),*(state_(m_src_it)++)) )</code>: the current
+ state has an attribute m_src_it (an iterator). If this iterator !=
+ fsm.m_src_container.end(), process OneSong on fsm, copy-constructed
+ from state.m_src_it which we post-increment</p></li></ul></div></div></div><div class="sect2" title="Back-end"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3425"></a>Back-end</h3></div></div></div><p>There is, at the moment, one back-end. This back-end contains the library engine
+ and defines the performance and functionality tradeoffs. The currently available
+ back-end implements most of the functionality defined by the UML 2.0 standard at
+ very high runtime speed, in exchange for longer compile-time. The runtime speed is
+ due to a constant-time double-dispatch and self-adapting capabilities allowing the
+ framework to adapt itself to the features used by a given concrete state machine.
+ All unneeded features either disable themselves or can be manually disabled. See
+ section 5.1 for a complete description of the run-to-completion algorithm.</p><div class="sect3" title="MSM Backend features"><div class="titlepage"><div><div><h4 class="title"><a name="d0e3430"></a> MSM Backend features </h4></div></div></div><p>TODO</p><p></p><div class="sect4" title="Creation"><div class="titlepage"><div><div><h5 class="title"><a name="d0e3436"></a> Creation </h5></div></div></div><p> MSM being divided betwenn front and back-end, one needs to first define a
+ front-end. Then, to create a real state machine, the back-end must be
+ created: <code class="code">typedef msm::back::state_machine&lt;my_front_end&gt;
+ my_fsm;</code>
+ </p><p>We now have a fully functional state machine. The next sections will
+ describe what can be done with it.</p></div><div class="sect4" title="Event dispatching"><div class="titlepage"><div><div><h5 class="title"><a name="d0e3446"></a>Event dispatching</h5></div></div></div><p>The main reason to exist for a state machine is to dispatch events. For
+ MSM, events are objects of a given event type. The object itself can contain
+ data, but the event type is what decides of the transition to be taken. For
+ MSM, if some_event is a given type (a simple struct for example) and e1 and
+ e2 concrete events, e1 and e2 are equivalent, from a transition perspective.
+ Of course, e1 and e2 can have different values and you can use them inside
+ actions. Events are dispatched as const reference, so actions cannot modify
+ events for obvious side-effect reasons. To dispatch an event of type
+ some_event, you can simply write: </p><p><code class="code">my_fsm fsm; fsm.process_event(some_event());</code></p><p><code class="code">some_event e1; fsm.process_event(e1)</code></p><p>Creating an event on the fly will be optimized by the compiler so the
+ performance will not degrade.</p></div><div class="sect4" title="Active state(s)"><div class="titlepage"><div><div><h5 class="title"><a name="d0e3459"></a>Active state(s)</h5></div></div></div><p>The backend also offers a way to know which state is active, though you
+ will normally only need this for debugging purposes. If what you need simply
+ is doing something with the active state, <span class="command"><strong><a class="command" href="ar01s03.html#UML-internal-transition">internal transitions</a></strong></span> or
+ <span class="command"><strong><a class="command" href="ar01s04.html#backend-visitor">visitors</a></strong></span> are a better
+ alternative. If you need to know what state is active, const int*
+ current_state() will return an array of state ids. Please refer to the
+ <span class="command"><strong><a class="command" href="ar01s07.html#internals-state-id">internals section</a></strong></span> to
+ know how state ids are generated.</p></div><div class="sect4" title="Base state type"><div class="titlepage"><div><div><h5 class="title"><a name="d0e3473"></a> Base state type </h5></div></div></div><p>Sometimes, one needs to customize states to avoid repetition and provide a
+ common functionality, for example in the form of a virtual method. You might
+ also want to make your states polymorphic so that you can call typeid on
+ them for logging or debugging. It is also useful if you need a visitor, like
+ the next section will show. You will notice that all front-ends offer the
+ possibility of adding a base type. Not that all states and state machines
+ must have the same base state, so this could reduce reuse. For example,
+ using the basic front end, you need to:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Add the non-default base state in your msm::front::state&lt;&gt;
+ definition, as first template argument (except for
+ interrupt_states for which it is the second argument, the first
+ one being the event ending the interrupt), for example,
+ my_base_state being your new base state for all states in a
+ given state machine: <code class="code">struct Empty : public
+ msm::front::state&lt;my_base_state&gt;</code> Now,
+ my_base_state is your new base state. If it has a virtual
+ function, your states become polymorphic. MSM also provides a
+ default polymorphic base type for your convenience,
+ <code class="code">msm::front::polymorphic_state</code>
+ </p></li><li class="listitem"><p>Add the user-defined base state in the state machine frontend
+ definition, as a second template argument, for example:
+ <code class="code">struct player_ : public
+ msm::front::state_machine&lt;player_,my_base_state&gt;
+ </code></p></li></ul></div><p>You can also ask for a state with a given id (which you might have gotten
+ from current_state()) using <code class="code">const base_state* get_state_by_id(int id)
+ const</code> where base_state is the one you just defined. You can now
+ do something ploymorphically. For example using the visitor.</p></div><div class="sect4" title="Visitor"><div class="titlepage"><div><div><h5 class="title"><a name="d0e3498"></a><span class="command"><strong><a name="backend-visitor"></a></strong></span>Visitor</h5></div></div></div><p>In some cases, having a pointer-to-base of the currently active states is
+ not enough. You might want to call non-virtually a method of the currently
+ active states. It will not be said that MSM forces the virtual keyword down
+ your throat!</p><p>To achieve this goal, MSM provides its own variation of a visitor pattern
+ using the previously described user-defined state technique. If you add to
+ your user-defined base state an <code class="code">accept_sig</code> typedef giving the
+ return value (unused for the moment) and signature and provide an accept
+ method with this signature, calling visit_current_states will cause accept
+ to be called on the currently active states. Typically, you will also want
+ to provide an empty default accept in your base state in order in order not
+ to force all your states to implement accept. For example your base state
+ could be:</p><p><code class="code">struct my_visitable_state{</code></p><p><code class="code">// signature of the accept function</code></p><p><code class="code">typedef args&lt;void&gt; accept_sig;</code></p><p><code class="code">// we also want polymorphic states</code></p><p><code class="code">virtual ~my_visitable_state() {}</code></p><p><code class="code">// default implementation for states who do not need to be
+ visited</code></p><p><code class="code">void accept() const {}</code></p><p><code class="code">};</code></p><p>This makes your states polymorphic and visitable. In this case, accept is
+ made const and takes no argument. It could also be:</p><p><code class="code">struct SomeVisitor {&#8230;};</code></p><p><code class="code">struct my_visitable_state{</code></p><p><code class="code">// signature of the accept function</code></p><p><code class="code">typedef args&lt;void,SomeVisitor&amp;&gt; accept_sig;</code></p><p><code class="code">// we also want polymorphic states</code></p><p><code class="code">virtual ~my_visitable_state() {}</code></p><p><code class="code">// default implementation for states who do not need to be
+ visited</code></p><p><code class="code">void accept(SomeVisitor&amp;) const {}</code></p><p><code class="code">};</code></p><p>And now, accept will take one argument (it could also be non-const). By
+ default, accept takes up to 2 arguments. To get more, add a #define
+ BOOST_MSM_VISITOR_ARG_SIZE to another value before including
+ state_machine.hpp. For example:</p><p><code class="code">#define BOOST_MSM_VISITOR_ARG_SIZE 3</code></p><p><code class="code">#include &lt;boost/msm/back/state_machine.hpp&gt;</code></p><p>Note that accept will be called on ALL active states <span class="underline">and also automatically on sub-states of a
+ submachine</span>.</p><p><span class="underline">Important warning</span>: The method
+ visit_current_states takes its parameter by value, so if the signature of
+ the accept function is to contain a parameter passed by reference, pass this
+ parameter with a boost:ref/cref to avoid undesired copies or slicing. So,
+ for example, in the above case, call:</p><p><code class="code">SomeVisitor vis; sm.visit_current_states(boost::ref(vis));
+ </code></p><p>This <a class="link" href="examples/SM-2Arg.cpp" target="_top">example</a> uses a
+ visiting function with 2 arguments.</p></div><div class="sect4" title="Flags"><div class="titlepage"><div><div><h5 class="title"><a name="d0e3587"></a>Flags</h5></div></div></div><p>Flags is a MSM-only concept, supported by all front-ends, which base
+ themselves on the functions: </p><p><code class="code">template &lt;class Flag&gt; bool is_flag_active()</code> and</p><p><code class="code">template &lt;class Flag,class BinaryOp&gt; bool is_flag_active()</code>
+ </p><p>These functions return true if the currently active state(s) support the
+ Flag property. The first variant ORs the result if there are several
+ orthogonal regions, the second one expects OR or AND, for example:</p><p><code class="code">my_fsm.is_flag_active&lt;MyFlag&gt;()</code></p><p><code class="code">my_fsm.is_flag_active&lt;MyFlag,my_fsm_type::Flag_OR&gt;()</code></p><p>Please refer to the front-ends sections for more information.</p></div><div class="sect4" title="Getting a state"><div class="titlepage"><div><div><h5 class="title"><a name="d0e3610"></a>Getting a state</h5></div></div></div><p>It is sometimes necessary to have the client code get access to the
+ states' data. After all, the states are created once for good and hang
+ around as long as the state machine does so why not use it? You simply just
+ need sometimes to get information about any state, even inactive ones. An
+ example is if you want to write a coverage tool and know how many times a
+ state was visited. To get a state, use the get_state method giving the state
+ name, for example: </p><p><code class="code">player::Stopped* tempstate =
+ p.get_state&lt;player::Stopped*&gt;();</code> or </p><p><code class="code">player::Stopped&amp; tempstate2 =
+ p.get_state&lt;player::Stopped&amp;&gt;();</code> depending on your
+ personal taste. </p></div><div class="sect4" title="State machine constructor with arguments"><div class="titlepage"><div><div><h5 class="title"><a name="d0e3623"></a> State machine constructor with arguments </h5></div></div></div><p>You might want to define a state machine with a non-default constructor.
+ For example, you might want to write: </p><p><code class="code">struct player_ : public msm::front::state_machine_def&lt;player_&gt; {
+ player_(int some_value){&#8230;} } </code></p><p>This is possible, using the back-end as forwarding object: </p><p><code class="code">typedef msm::back::state_machine&lt;player_ &gt; player; player
+ p(3);</code> The back-end will call the corresponding front-end
+ constructor upon creation.</p><p>You can pass arguments up to the value of the
+ BOOST_MSM_CONSTRUCTOR_ARG_SIZE macro (currently 5) arguments. Change this
+ value before including any header if you need to change it. </p></div></div></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ar01s03.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ar01s05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">UML Short Guide&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp; Performance / Compilers</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ar01s05.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ar01s05.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,69 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Performance / Compilers</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="index.html" title="Meta State Machine (MSM)"><link rel="prev" href="ar01s04.html" title="User's Guide"><link rel="next" href="ar01s06.html" title="Questions &amp; Answers"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center"> Performance / Compilers</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s04.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ar01s06.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Performance / Compilers"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e3639"></a> Performance / Compilers</h2></div></di
v></div><p>Tests were made on different PCs running Windows XP and Vista and compiled with VC9
+ SP1 or Ubuntu and compiled with g++ 4.2 and 4.3. For these tests, the same player state
+ machine was written using Boost.Statechart, as a <a class="link" href="examples/SC Simple.cpp" target="_top">state machine with only simple states</a> and
+ as a <a class="link" href="examples/SC Composite.cpp" target="_top">state machine with a composite
+ state</a>. The same simple and composite state machines are implemented with MSM
+ with a standard frontend <a class="link" href="examples/MsmSimple.cpp" target="_top">(simple)</a><a class="link" href="examples/MsmComposite.cpp" target="_top">(composite)</a>, the simple one also with
+ <a class="link" href="examples/MsmSimpleFunctors.cpp" target="_top">functors</a> and with <a class="link" href="examples/EumlSimple.cpp" target="_top">eUML</a>. As these simple machines need no
+ terminate/interrupt states, no message queue and have no-throw guarantee on their
+ actions, the MSM state machines are defined with minimum functionality.</p><div class="sect2" title="Speed"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3661"></a>Speed</h3></div></div></div><p>VC9:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>The simple test completes 36 times faster with Msm than with
+ Boost.Statechart</p></li><li class="listitem"><p>The composite test completes 18 times faster with MSM</p></li><li class="listitem"><p>The fastest version is with eUML/functors. It completes 58 times
+ faster than Boost.Statechart. A transition costs 4.5ns on a
+ Q6600.</p></li></ul></div><p>gcc 4.2.3:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>The simple test completes 54 times faster with Msm (with
+ functors)</p></li><li class="listitem"><p>The composite test completes 25 times faster with Msm</p></li></ul></div></div><div class="sect2" title="Executable size"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3685"></a>Executable size</h3></div></div></div><p>There are some worries that MSM generates huge code. Is it true? The 2 compilers I
+ tested disagree with this claim. On VC9, the test state machines used in the
+ performance section produce executables of 14kB (for simple and eUML) and 21kB (for
+ the composite). This includes the test code and iostreams. By comparison, an empty
+ executable with iostreams generated by VC9 has a size of 7kB. Boost.Statechart
+ generates executables of 43kB and 54kB. As a bonus, eUML comes for &#8220;free&#8221; in terms
+ of executable size. You even get a speed gain. With g++ 4.3, it strongly depends on
+ the compiler options (much more than VC). A good size state machine with &#8211;O3 can
+ generate an executable of 600kB, and with eUML you can get to 1.5MB. Trying with &#8211;Os
+ &#8211;s I come down to 18kB and 30kB for the test state machines, while eUML will go down
+ to 1MB (which is still big), so in this case eUML does not come for free.</p></div><div class="sect2" title="Supported compilers"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3690"></a>Supported compilers</h3></div></div></div><p> MSM was successfully tested with: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>VC8 (please read further), VC9SP1, VC10 Beta 1 and 2</p></li><li class="listitem"><p>g++ 4.1 and higher</p></li><li class="listitem"><p>Green Hills Software MULTI for ARM v5.0.5 patch 4416 (Simple and
+ Composite tutorials)</p></li></ul></div><p> eUML will only work with: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>VC8 (partly). You cannot, however use any overloaded function (like
+ splice) and compile times and RAM consumption explode</p></li><li class="listitem"><p>VC9SP1, VC10 Beta1-2</p></li><li class="listitem"><p>g++ 4.3 and higher (previous versions lack native typeof
+ support)</p></li></ul></div><p>VC8 and to some lesser extent VC9 suffer from a bug. Enabling the option "Enable
+ Minimal Rebuild" (/Gm) will cause much higher compile-time (up to three times with
+ VC8!). This option being activated per default in Debug mode, this can be a big
+ problem.</p></div><div class="sect2" title="Limitations"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3719"></a> Limitations </h3></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Compilation times of state machines with &gt; 80 transitions that are
+ going to make you storm the CFO's office and make sure you get a shiny
+ octocore with 8GB RAM by next week, unless he's interested in paying you
+ watch the compiler agonize for hours... (Make sure you ask for dual 24"
+ as well, it doesn't hurt).</p></li><li class="listitem"><p>eUML allows very long constructs but will also quickly increase your
+ compile time on some compilers (VC9, VC10 Beta1) with buggy decltype
+ support (I suspect some at least quadratic algorithms there). Even g++
+ 4.4 shows some regression compared to 4.3 and will crash if the
+ constructs become too big.</p></li><li class="listitem"><p>Need to overwrite the mpl::vector/list default-size-limit of 20 and
+ fusion default vector size of 10 if more than 10 states found in a state
+ machine</p></li></ul></div><p>
+ </p></div><div class="sect2" title="Compilers corner"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3735"></a> Compilers corner </h3></div></div></div><p>Compilers are sometimes full of surprises and such strange errors happened in the
+ course of the development that I wanted to list the most fun for readers&#8217;
+ entertainment.</p><p><span class="underline">VC8</span>: </p><p><code class="code">template &lt;class StateType&gt; </code></p><p><code class="code">typename ::boost::enable_if&lt; </code></p><p><code class="code">typename ::boost::mpl::and_&lt;</code></p><p><code class="code">typename ::boost::mpl::not_&lt;typename
+ has_exit_pseudo_states&lt;StateType&gt;::type&gt;::type, </code></p><p><code class="code">typename ::boost::mpl::not_&lt;typename
+ is_pseudo_exit&lt;StateType&gt;::type&gt;::type &gt;::type,BaseState*&gt;::type
+ </code></p><p>I get the following error:</p><p>error C2770: invalid explicit template argument(s) for '`global
+ namespace'::boost::enable_if&lt;is_pseudo_exit&lt;StateType&gt;::type,BaseState*&gt;::type
+ boost::msm::state_machine&lt;Derived,HistoryPolicy,BaseState&gt;::add_state&lt;ContainingSM&gt;::new_state_helper(boost::msm::dummy&lt;__formal&gt;)
+ const' </p><p>If I now remove the first &#8220;::&#8221; in ::boost::mpl , the compiler shuts up. So in this
+ case, it is not possible to follow Boost&#8217;s guidelines.</p><p><span class="underline">VC9</span>:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>This one is my all times&#8217; favorite. Do you know why the exit pseudo
+ states are referenced in the transition table with a
+ &#8220;submachine::exit_pt&#8221; ? Because &#8220;exit&#8221; will crash the compiler. &#8220;Exit&#8221;
+ is not possible either because it will crash the compiler on one
+ machine, but not on another (the compiler was installed from the same
+ disk).</p></li><li class="listitem"><p>Sometimes, removing a policy crashes the compiler, so some versions
+ are defining a dummy policy called WorkaroundVC9.</p></li><li class="listitem"><p>Typeof: While g++ and VC9 compile &#8220;standard&#8221; state machines in
+ comparable times, Typeof (while in both ways natively supported) seems
+ to behave in a quadratic complexity with VC9 and VC10.</p></li><li class="listitem"><p>eUML: in case of a compiler crash, changing the order of state
+ definitions (first states without entry or exit) sometimes solves the
+ problem.</p></li></ul></div><p><span class="underline">g++ 4.x</span>: Boring compiler, almost all is
+ working almost as expected. Being not a language lawyer I am unsure about the
+ following &#8220;Typeof problem&#8221;. VC9 and g++ disagree on the question if you can derive
+ from the BOOST_TYPEOF generated type without first defining a typedef. I will be
+ thankful for an answer on this. I only found two ways to break the compiler:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Add more eUML constructs until something explodes (especially with
+ g++-4.4) </p></li><li class="listitem"><p>The build_terminate function uses 2 mpl::push_back instead of
+ mpl::insert_range because g++ would not accept insert_range.</p></li></ul></div><p>You can test your compiler&#8217;s decltype implementation with the <a class="link" href="examples/CompilerStressTestEuml.cpp" target="_top">following stress test</a>
+ and reactivate the commented-out code until the compiler crashes.</p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ar01s04.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ar01s06.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">User's Guide&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Questions &amp; Answers</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ar01s06.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ar01s06.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,29 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Questions &amp; Answers</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="index.html" title="Meta State Machine (MSM)"><link rel="prev" href="ar01s05.html" title="Performance / Compilers"><link rel="next" href="ar01s07.html" title="Internals"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Questions &amp; Answers</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s05.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ar01s07.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Questions &amp; Answers"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e3798"></a>Questions &amp; Answers</h2></div></div></d
iv><p><span class="underline">Question</span>: on_entry gets as argument, the sent
+ event. What event do I get when the state becomes default-activated (because it is an
+ initial state)?</p><p>
+ <span class="underline">Answer</span>: To allow you to know that the state was
+ default-activated, MSM generates a boost::msm::InitEvent default event. </p><p><span class="underline">Question</span>: Why do I see no call to no_transition
+ in my composite state? </p><p><span class="underline">Answer</span>: Because of the priority rule defined by
+ UML. It says that in case of transition conflict, the most inner state has a higher
+ priority. So after asking the inner state, the containing composite has to be also asked
+ to handle the transition and could find a possible transition.</p><p><span class="underline">Question</span>: Why do I get a compile error saying
+ the compiler cannot convert to a function ...Fsm::*(some_event)? </p><p><span class="underline">Answer</span>: You probably defined a transition
+ triggered by the event some_event, but used a guard/action method taking another event. </p><p><span class="underline">Question</span>: Why do I get a compile error saying
+ something like &#8220;too few&#8221; or &#8220;too many&#8221; template arguments? </p><p><span class="underline">Answer</span>: You probably defined a transition in
+ form of a a_row or g_row where you wanted just a _row or the other way around. With Row,
+ it could mean that you forgot a "none". </p><p><span class="underline">Question</span>: Why do I get a very long compile error
+ when I define more than 20 rows in the transition table? </p><p><span class="underline">Answer</span>: MSM uses Boost.MPL under the hood and
+ this is the default maximum size. Please define the following 3 macros before including
+ any MSM headers: </p><p><code class="code">#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS </code></p><p><code class="code">#define BOOST_MPL_LIMIT_VECTOR_SIZE 30 // or whatever you need </code></p><p><code class="code">#define BOOST_MPL_LIMIT_MAP_SIZE 30 // or whatever you need </code></p><p><span class="underline">Question</span>: Why do I get this error: &#8221;error C2977:
+ 'boost::mpl::vector' : too many template arguments&#8221;? </p><p><span class="underline">Answer</span>: The first possibility is that you
+ defined a transition table as, say, vector17 and have 18 entries. The second is that you
+ have 17 entries and have a composite state. Under the hood, MSM adds a row for every
+ event in the composite transition table. The third one is that you used a mpl::vector
+ without the number of entries but are close to the MPL default of 50 and have a
+ composite, thus pushing you above 50. Then you need mpl/vector60/70&#8230;.hpp and a
+ mpl/map60/70&#8230;.hpp </p><p><span class="underline">Question</span>: Why do I get a very long compile error
+ when I define more than 10 states in a state machine? </p><p><span class="underline">Answer</span>: Msm uses Boost.Fusion under the hood and
+ this is the default maximum size. Please define the following macro before including any
+ MSM headers: </p><p><code class="code">#define FUSION_MAX_VECTOR_SIZE 20 // or whatever you need </code></p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ar01s05.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ar01s07.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top"> Performance / Compilers&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Internals</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ar01s07.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ar01s07.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,149 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Internals</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="index.html" title="Meta State Machine (MSM)"><link rel="prev" href="ar01s06.html" title="Questions &amp; Answers"><link rel="next" href="ar01s08.html" title="Acknowledgements"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Internals</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s06.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ar01s08.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Internals"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e3870"></a>Internals</h2></div></div></div><p>This chapter describes the internal machine
ry of the back-end, which can be useful for
+ UML experts but can be safely ignored for most users. For implementers, the interface
+ between front- and back- end is also described in detail.</p><div class="sect2" title="Backend: Run To Completion"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3875"></a><span class="command"><strong><a name="run-to-completion"></a></strong></span>Backend: Run To Completion</h3></div></div></div><p>The back-end implements the following run-to completion algorithm:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Check if one region of the concrete state machine is in a terminate or
+ interrupt state. If yes, event processing is disabled while the
+ condition perdures (forever for a terminate pseudo-state, while active
+ for an interrupt pseudo-state).</p></li><li class="listitem"><p>If the message queue feature is enabled and if the state machine is
+ already processing an event, push the currently processed event into the
+ queue and end processing. Otherwise, notice that the state machine is
+ now processing an event and continue.</p></li><li class="listitem"><p>If the state machine detected that no deferred event is used, skip
+ this step. Otherwise, mark the first deferred event from the deferred
+ queue as active.</p></li><li class="listitem"><p>Now start the core of event dispatching. If exception handling is
+ activated, this will happen inside a try/catch block and the front-end
+ <code class="code">exception_caught</code> is called if an exception occurs.
+ </p></li><li class="listitem"><p>The event is now dispatched in turn to every region, in the order
+ defined by the initial state front-end definition. This will, for every
+ region, call the corresponding front-end transition definition (the
+ "row" or "Row" of the transition table).</p></li><li class="listitem"><p>Without transition conflict, if for a given region a transition is
+ possible, the guard condition is checked. If it returns
+ <code class="code">true</code>, the transition processing continues and the
+ current state's exit action is called, followed by the transition action
+ and the new active state's entry action.</p></li><li class="listitem"><p>With transition conflicts (several possible transitions, disambiguated
+ by mutually exclusive guard conditions), the guard conditions are tried
+ in reverse order of their transition definition in the transition table.
+ The first one returning <code class="code">true</code> selects its transition. Note
+ that this is not defined by the UML standard, which simply specifies
+ that if the guard conditions are not mutually exclusive, the state
+ machine is ill-formed and the behaviour undefined. Relying on this
+ implementation-specific behaviour will make it harder for the developer
+ to support another state machine framework.</p></li><li class="listitem"><p>If at least one region processes the event, this event is seen as
+ having been accepted. If not, the library calls
+ <code class="code">no_transition</code> on the state machine for every contained
+ region.</p></li><li class="listitem"><p>If the currently active state is a submachine, the behaviour is
+ slightly different. The UML standard specifies that internal transitions
+ have to be tried first, so the event is first dispatched to the
+ submachine. Only if the submachine does not accept the event are other
+ (non internal) transitions tried.</p></li><li class="listitem"><p>This back-end supports simple states' and submachines' internal
+ transitions. These are provided in the state's
+ <code class="code">internal_transition_table</code> type. Transitions defined in
+ this table are added at the end of the main state machine's transition
+ table, but with a lesser priority than the submachine's transitions
+ (defined in <code class="code">transition_table</code>). This means, for simple
+ states, that these transitions have higher priority than non-internal
+ transitions, conform to the UML standard which gives higher priority to
+ deeper-level transitions. For submachines, this is a non-standard
+ addition which can help make event processing faster by giving a chance
+ to bypass subregion processing. With standard UML, one would need to add
+ a subregion only to process these internal transitions, which would be
+ slower.</p></li><li class="listitem"><p>After the dispatching itself, the deferred event marked in step 3 (if
+ any) now gets a chance of processing.</p></li><li class="listitem"><p>Then, events queued in the message queue also get a dispatching
+ chance</p></li><li class="listitem"><p>Finally, compound events (transitions without a named event), if to be
+ found in the transition table, also get their dispatching chance.</p></li></ul></div><p>This algorithm illustrates how the back-end configures itself at compile-time as
+ much as possible. Every feature not found in a given state machine definition is
+ deactivated and has therefore no runtime cost. Compound events, deferred events,
+ terminate states, dispatching to several regions, internal transitions are all
+ deactivated if not used. Only for exception handling and message queue is user
+ configuration necessary.</p></div><div class="sect2" title="Frontend / Backend interface"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3941"></a>Frontend / Backend interface</h3></div></div></div><p>The design of MSM tries to make front-ends and back-ends (later) to be as
+ interchangeable as possible. Of course, Of course, no back-end will ever implement
+ every feature defined by any possible front-end and inversely, but the goal is to
+ make it as easy as possible to extend the current state of the library.</p><p>To achieve this, MSM divides the functionality between both sides: the front-end
+ is a sort of user interface and is descriptive, the back-end implements the state
+ machine engine.</p><p>MSM being based on a transition table, a concrete state machine (or a given
+ front-end) must provide a transition_table. This transition table must be made of
+ rows. And each row must tell what kind of transition it is and implement the calls
+ to the actions and guards. A state machine must also define its regions (marked by
+ initial states) And that is about the only constraints for front-ends. How the rows
+ are described is implementer's choice. </p><p>Every row must provide:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>A <code class="code">Source</code> typedef indicating, well, the type of the source
+ state.</p></li><li class="listitem"><p>A <code class="code">Target</code> typedef indicating, well, the type of the target
+ state.</p></li><li class="listitem"><p>A <code class="code">Evt</code> typedef indicating the type of the event triggering the
+ transition.</p></li><li class="listitem"><p>A <code class="code">row_type_tag</code> typedef indicating the type of the
+ transition.</p></li><li class="listitem"><p>Rows having a type requiring transition actions must provide a static
+ function <code class="code">action_call</code> with the following signature: <code class="code">
+ template &lt;class Fsm,class SourceState,class TargetState,class
+ AllStates&gt; </code></p><p><code class="code">static void action_call (Fsm&amp; fsm, Event const&amp; evt,
+ SourceState&amp;, TargetState&amp;, AllStates&amp;) </code></p><p>The function gets as parameters the (back-end) state machine, the event,
+ source and target states and a container (in the current back-end, a
+ fusion::set) of all the states defined in the state machine. For example, as
+ the back-end has the front-end as basic class, <code class="code">action_call</code> is
+ simply defined as <code class="code">(fsm.*action)(evt)</code>.</p></li><li class="listitem"><p>Rows having a type requiring a guard must provide a static function
+ <code class="code">guard_call</code> with the following signature:<code class="code"> </code></p><p><code class="code">template &lt;class Fsm,class SourceState,class TargetState,class
+ AllStates&gt;</code></p><p><code class="code">static bool guard_call (Fsm&amp;, Event const&amp;,
+ SourceState&amp;, TargetState&amp;, AllStates&amp;)</code></p></li><li class="listitem"><p>The possible transition (row) types are:</p><div class="itemizedlist"><ul class="itemizedlist" type="circle"><li class="listitem"><p>a_row_tag: a transition with actions and no guard</p></li><li class="listitem"><p>g_row_type: a transition with a guard and no actions</p></li><li class="listitem"><p>_row_tag: a transition without actions or guard</p></li><li class="listitem"><p>row_tag: a transition with guard and actions</p></li><li class="listitem"><p>a_irow_tag: an internal transition (defined inside the
+ <code class="code">transition_table</code>) with actions</p></li><li class="listitem"><p>g_irow_tag: an internal transition (defined inside the
+ <code class="code">transition_table</code>) with guard</p></li><li class="listitem"><p>irow_tag: an internal transition (defined inside the
+ <code class="code">transition_table</code>) with actions and
+ guards</p></li><li class="listitem"><p>_irow_tag: an internal transition (defined inside the
+ <code class="code">transition_table</code>) without action or guard. Due
+ to higher priority for internal transitions, this is quivalent
+ to a "ignore event"</p></li><li class="listitem"><p>sm_a_i_row_tag: an internal transition (defined inside the
+ <code class="code">internal_transition_table</code>) with actions</p></li><li class="listitem"><p>sm_g_i_row_tag: an internal transition (defined inside the
+ <code class="code">internal_transition_table</code>) with guard</p></li><li class="listitem"><p>sm_i_row_tag: an internal transition (defined inside the
+ <code class="code">internal_transition_table</code>) with actions and
+ guards</p></li><li class="listitem"><p>sm__i_row_tag: an internal transition (defined inside the
+ <code class="code">internal_transition_table</code>) without action or
+ guard. Due to higher priority for internal transitions, this is
+ quivalent to a "ignore event"</p></li></ul></div></li></ul></div><p>Furthermore, a front-end must provide the definition of states and state machines.
+ State machine definitions must provide (the implementer is free to provide it or let
+ it be done by every concrete state machine. Different MSM front-ends took one or the
+ other approach):</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">initial_state</code>: This typedef can be a single state or a
+ mpl container and provides the initial states defining one or several
+ orthogonal regions.</p></li><li class="listitem"><p><code class="code">transition_table</code>: This typedef is a MPL sequence of
+ rows.</p></li><li class="listitem"><p><code class="code">configuration</code>: this typedef is a MPL sequence of known
+ types triggering special behavior in the back-end, for example if a
+ concrete fsm requires a message queue or exception catching.</p></li></ul></div><p>States and state machines must both provide a (possibly empty) definition of:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">flag_list</code>: the flags being active when this state or
+ state machine become the current state of the fsm.</p></li><li class="listitem"><p><code class="code">deferred_events</code>: events being automatically deferred when
+ the state is the current state of the fsm.</p></li><li class="listitem"><p><code class="code">internal_transition_table</code>: the internal transitions of
+ this state.</p></li><li class="listitem"><p><code class="code">on_entry</code> and <code class="code">on_exit</code> methods.</p></li></ul></div></div><div class="sect2" title="Generated state ids"><div class="titlepage"><div><div><h3 class="title"><a name="d0e4118"></a><span class="command"><strong><a name="internals-state-id"></a></strong></span> Generated state ids </h3></div></div></div><p>Normally, one does not need to know the ids generated for all the states of a
+ state machine, unless for debugging purposes, like the pstate function does in the
+ tutorials in order to display the name of the current state. This section will show
+ how to automatically display typeid-generated names, but these are not very readable
+ on all platforms, so it can help to know how the ids are generated. The ids are
+ generated using the transition table, from the &#8220;Start&#8221; column up to down, then from
+ the &#8220;Next&#8221; column, up to down, as shown in the next image: </p><p><span class="inlinemediaobject"><img src="../images/AnnexA.jpg"></span></p><p>Stopped will get id 0, Open id 1, ErrorMode id 6 and SleepMode (seen only in the
+ &#8220;Next&#8221; column) id 7. If you have some implicitly created states, like
+ transition-less initial states or states created using the explicit_creation
+ typedef, these will be added as a source at the end of the transition table. If you
+ have submachine states, a row will be added for them at the end of the table, after
+ the automatically or explicitly created states, which can change their id. The next
+ help you will need for debugging would be to call the current_state method of the
+ state_machine class, then the display_type helper to generate a readable name from
+ the id. If you do not want to go through the transition table to fill an array of
+ names, the library provides another helper, fill_state_names, which, given an array
+ of sufficient size (please see next section to know how many states are defined in
+ the state machine), will fill it with typeid-generated names. </p></div><div class="sect2" title="Metaprogramming tools"><div class="titlepage"><div><div><h3 class="title"><a name="d0e4130"></a>Metaprogramming tools</h3></div></div></div><p>We can find for the transition table more uses than what we have seen so far.
+ Let's suppose you need to write a coverage tool. A state machine would be perfect
+ for such a job, if only it could provide some information about its structure. It is
+ especially relevant if you are working with Executable UML, which bases most of its
+ dynamic behaviour on state machines.As a matter of fact, thanks to the transition
+ table and Boost.MPL, it does.</p><p>What is needed for a coverage tool? You need to know how many states are defined
+ in the state machine, and how many events can be fired. This way you can log the
+ fired events and the states visited in the life of a concrete machine and be able to
+ perform some coverage analysis, like &#8220;fired 65% of all possible events and visited
+ 80% of the states defined in the state machine&#8221;. To achieve this, MSM provides a few
+ useful tools:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>generate_state_set&lt;transition table&gt;: returns a mpl::set of all the
+ states defined in the table.</p></li><li class="listitem"><p>generate_event_set&lt;transition table&gt;: returns a mpl::set of all the
+ events defined in the table.</p></li><li class="listitem"><p>using mpl::size&lt;&gt;::value you can get the number of elements in the
+ set.</p></li><li class="listitem"><p>display_type defines an operator() sending typeid(Type).name() to
+ cout.</p></li><li class="listitem"><p>fill_state_names fills an array of char const* with names of all
+ states (found by typeid)</p></li><li class="listitem"><p>using mpl::for_each on the result of generate_state_set and
+ generate_event_set passing display_type as argument will display all the
+ states of the state machine.</p></li><li class="listitem"><p>let's suppose you need to recursively find the states and events
+ defined in the composite states and thus also having a transition table.
+ Calling recursive_get_transition_table&lt;Composite&gt; will return you the
+ transition table of the composite state, recursively adding the
+ transition tables of all sub-state machines and sub-sub...-sub-state
+ machines. Then call generate_state_set or generate_event_set on the
+ result to get the full list of states and events. </p></li></ul></div><p> An <a class="link" href="examples/BoostCon09Full.cpp" target="_top">example</a> shows the tools
+ in action. </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ar01s06.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ar01s08.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Questions &amp; Answers&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Acknowledgements</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ar01s08.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ar01s08.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,20 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Acknowledgements</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="index.html" title="Meta State Machine (MSM)"><link rel="prev" href="ar01s07.html" title="Internals"><link rel="next" href="ar01s09.html" title="Reference"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Acknowledgements</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s07.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ar01s09.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Acknowledgements"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4164"></a>Acknowledgements</h2></div></div></div><p>I am in debt to the following people
 who helped MSM along the way.</p><div class="sect2" title="MSM v2"><div class="titlepage"><div><div><h3 class="title"><a name="d0e4169"></a>MSM v2</h3></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Thanks to Dave Abrahams for managing the review</p></li><li class="listitem"><p>Thanks to Eric Niebler for his patience correcting my grammar
+ errors</p></li><li class="listitem"><p>Special thanks to Joel de Guzman who gave me very good ideas at the
+ BoostCon09. These ideas were the starting point of the redesign. Any
+ time again, Joel &#9786;</p></li><li class="listitem"><p>Thanks to Richard O&#8217;Hara for making Green Hills bring a patch in less
+ than 1 week, thus adding one more compiler to the supported list.</p></li><li class="listitem"><p>Big thanks to those who took the time to write a review: Franz Alt,
+ David Bergman, Michael Caisse, Barend Gehrels, Darryl Greene, Juraj
+ Ivancic, Erik Nelson, Kenny Riddile.</p></li><li class="listitem"><p>Thanks to Matt Calabrese and Juraj Ivancic for reporting bugs.</p></li></ul></div><p>
+ </p></div><div class="sect2" title="MSM v1"><div class="titlepage"><div><div><h3 class="title"><a name="d0e4194"></a> MSM v1</h3></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>The original version of this framework is based on the brilliant work
+ of David Abrahams and Aleksey Gurtovoy who laid down the base and the
+ principles of the framework in their excellent book, &#8220;C++ template
+ Metaprogramming&#8221;. The implementation also makes heavy use of the
+ boost::mpl.</p></li><li class="listitem"><p>Thanks to Jeff Flinn for his idea of the user-defined base state and
+ his review which allowed MSM to be presented at the BoostCon09.</p></li><li class="listitem"><p>Thanks to my Msm v1beta testers, Christoph Woskowski and Franz Alt for
+ using the framework with little documentation and to my private
+ reviewer, Edouard Alligand</p></li></ul></div><p>
+ </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ar01s07.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ar01s09.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Internals&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Reference</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ar01s09.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ar01s09.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,120 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Reference</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="index.html" title="Meta State Machine (MSM)"><link rel="prev" href="ar01s08.html" title="Acknowledgements"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Reference</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s08.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;</td></tr></table><hr></div><div class="sect1" title="Reference"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4210"></a>Reference</h2></div></div></div><p> todo </p><div class="sect2" title="Back-end"><div class="titlepage"><div><div><h3 class="title"><a name="d0e4215"></a> Back-end </h3></div></div></div><p>to
do</p><div class="sect3" title="File: <boost/msm/back/state_machine.hpp&gt;"><div class="titlepage"><div><div><h4 class="title"><a name="d0e4220"></a>File: &lt;boost/msm/back/state_machine.hpp&gt;</h4></div></div></div><pre class="synopsis">
+ <code class="filename">boost/msm/back/state_machine.hpp</code>
+ <code class="classname">fff</code>
+ <code class="methodname">void start</code>
+ <code class="methodname">template &lt;class Event&gt; HandledEnum process_event</code>
+ <code class="methodname">const int* current_state const</code>
+ </pre><pre class="classsynopsis"> <span class="ooclass"><span class="classname">template &lt;class Derived,class HistoryPolicy=NoHistory,class
+ CompilePolicy=favor_runtime_speed&gt; state_machine</span></span>&nbsp;{<br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">void start</span>(<span class="methodparam"></span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">template &lt;class Event&gt; HandledEnum process_event</span>(<span class="methodparam">Event const&amp;</span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">const int* current_state const</span>(<span class="methodparam"></span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">const BaseState* get_state_by_id const</span>(<span class="methodparam">int id</span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">bool is_contained const</span>(<span class="methodparam"></span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">template &lt;class State&gt; State* get_state</span>(<span class="methodpar
am"></span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">template &lt;class State&gt; State&amp; get_state</span>(<span class="methodparam"></span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">template &lt;class Flag,class BinaryOp&gt; bool
+ is_flag_active</span>(<span class="methodparam"></span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">template &lt;class Flag&gt; bool is_flag_active</span>(<span class="methodparam"></span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">void visit_current_states</span>(<span class="methodparam"></span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">void visit_current_states</span>(<span class="methodparam">any-type param1, any-type param2,...</span>);</code><br><code class="methodsynopsis">&nbsp;&nbsp;<span class="methodname">template &lt;class Event&gt; void defer_event</span>(<span class="methodparam">Event const&amp;</span>);</code><br>}</pre></div></div><div class="sect2" title="eUML functions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e4309"></a>eUML functions</h3></div></div></div><p>The following table lists the supported operators: </p><p>
+ </p><div class="table"><a name="d0e4316"></a><p class="title"><b>Table&nbsp;1.&nbsp;Operators and state machine helpers</b></p><div class="table-contents"><table summary="Operators and state machine helpers" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>eUML function / operator</th><th>Description</th><th>Functor</th></tr></thead><tbody><tr><td>&amp;&amp;</td><td>Calls lazily Action1&amp;&amp; Action2</td><td>And_</td></tr><tr><td>||</td><td>Calls lazily Action1|| Action2</td><td>Or_</td></tr><tr><td>!</td><td>Calls lazily !Action1</td><td>Not_</td></tr><tr><td>!=</td><td>Calls lazily Action1 != Action2</td><td>NotEqualTo_</td></tr><tr><td>==</td><td>Calls lazily Action1 == Action2</td><td>EqualTo_</td></tr><tr><td>&gt;</td><td>Calls lazily Action1 &gt; Action2</td><td>Greater_</td></tr><tr><td>&gt;=</td><td>Calls lazily Action1 &gt;= Action2</td><td>Greater_Equal_</td></tr><tr><td>&lt;</td><td>Calls lazily Action1 &lt; Action2</td><td>Less_</td></tr><tr><td>&lt;=</td><td>Cal
ls lazily Action1 &lt;= Action2</td><td>Less_Equal_</td></tr><tr><td>&amp;</td><td>Calls lazily Action1 &amp; Action2</td><td>Bitwise_And_</td></tr><tr><td>|</td><td>Calls lazily Action1 | Action2</td><td>Bitwise_Or_</td></tr><tr><td>^</td><td>Calls lazily Action1 ^ Action2</td><td>Bitwise_Xor_</td></tr><tr><td>--</td><td>Calls lazily --Action1 / Action1--</td><td>Pre_Dec_ / Post_Dec_</td></tr><tr><td>++</td><td>Calls lazily ++Action1 / Action1++</td><td>Pre_Inc_ / Post_Inc_</td></tr><tr><td>/</td><td>Calls lazily Action1 / Action2</td><td>Divides_</td></tr><tr><td>/=</td><td>Calls lazily Action1 /= Action2</td><td>Divides_Assign_</td></tr><tr><td>*</td><td>Calls lazily Action1 * Action2</td><td>Multiplies_</td></tr><tr><td>*=</td><td>Calls lazily Action1 *= Action2</td><td>Multiplies_Assign_</td></tr><tr><td>+ (binary)</td><td>Calls lazily Action1 + Action2</td><td>Plus_</td></tr><tr><td>+ (unary)</td><td>Calls lazily +Action1</td><td>Unary_Plus_</td></tr><tr><td>+=</td><td>Calls lazily Action1 += Action2</
td><td>Plus_Assign_</td></tr><tr><td>- (binary)</td><td>Calls lazily Action1 - Action2</td><td>Minus_</td></tr><tr><td>- (unary)</td><td>Calls lazily -Action1</td><td>Unary_Minus_</td></tr><tr><td>-=</td><td>Calls lazily Action1 -= Action2</td><td>Minus_Assign_</td></tr><tr><td>%</td><td>Calls lazily Action1 % Action2</td><td>Modulus_</td></tr><tr><td>%=</td><td>Calls lazily Action1 %= Action2</td><td>Modulus_Assign_</td></tr><tr><td>&gt;&gt;</td><td>Calls lazily Action1 &gt;&gt; Action2</td><td>ShiftRight_</td></tr><tr><td>&gt;&gt;=</td><td>Calls lazily Action1 &gt;&gt;= Action2</td><td>ShiftRight_Assign_</td></tr><tr><td>&lt;&lt;</td><td>Calls lazily Action1 &lt;&lt; Action2</td><td>ShiftLeft_</td></tr><tr><td>&lt;&lt;=</td><td>Calls lazily Action1 &lt;&lt;= Action2</td><td>ShiftLeft_Assign_</td></tr><tr><td>[] (works on vector, map, arrays)</td><td>Calls lazily Action1 [Action2]</td><td>Subscript_</td></tr><tr><td>if_then_else_(Condition,Action1,Action2)</td><td>Returns either the result of calling Action
1 or the result of
+ calling Action2</td><td>If_Else_</td></tr><tr><td>if_then_(Condition,Action)</td><td>Returns the result of calling Action if Condition</td><td>If_Then_</td></tr><tr><td>while_(Condition, Body)</td><td>While Condition(), calls Body(). Returns nothing</td><td>While_Do_</td></tr><tr><td>do_while_(Condition, Body)</td><td>Calls Body() while Condition(). Returns nothing</td><td>Do_While_</td></tr><tr><td>for_(Begin,Stop,EndLoop,Body)</td><td>Calls for(Begin;Stop;EndLoop){Body;}</td><td>For_Loop_</td></tr><tr><td>process_(Event [,fsm1] [,fsm2] [,fsm3] [,fsm4])</td><td>Processes Event on the current state machine (if no fsm
+ specified) or on up to 4 state machines returned by an
+ appropriate functor.</td><td>Process_</td></tr><tr><td>process2_(Event, Data [,fsm1] [,fsm2] [,fsm3])</td><td>Processes Event on the current state machine (if no fsm
+ specified) or on up to 2 state machines returned by an
+ appropriate functor. The event is copy-constructed from what
+ Data() returns.</td><td>Process2_</td></tr><tr><td>is_flag_(Flag [,fsm])</td><td>Calls is_flag_active() on the current state machine or the
+ one returned by calling fsm.</td><td>Get_Flag_</td></tr><tr><td>event_ [(attribute name)]</td><td>Returns the current event (as const reference)</td><td>GetEvent_</td></tr><tr><td>source_ [(attribute name)]</td><td>Returns the source state of the currently triggered
+ transition (as reference). If an attribute name is provided,
+ returns the attribute by reference.</td><td>GetSource_</td></tr><tr><td>target_ [(attribute name)]</td><td>Returns the target state of the currently triggered
+ transition (as reference). If an attribute name is provided,
+ returns the attribute by reference.</td><td>GetTarget_</td></tr><tr><td>state_ [(attribute name)]</td><td>Returns the source state of the currently active state (as
+ reference). Valid inside a state entry/exit action. If an
+ attribute name is provided, returns the attribute by
+ reference.</td><td>GetState_</td></tr><tr><td>fsm_ [(attribute name)]</td><td>Returns the current state machine (as reference). Valid
+ inside a state entry/exit action or a transition. If an
+ attribute name is provided, returns the attribute by
+ reference.</td><td>GetFsm_</td></tr><tr><td>substate_(state_name [,fsm])</td><td>Returns (as reference) the state state_name referenced in the
+ current state machine or the one given as argument.</td><td>SubState_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>TODO macro for functor def</p><p>To use these functions, you need to include: </p><p><code class="code">#include &lt;msm/front/euml/euml.hpp&gt;</code></p></div><div class="sect2" title="Functional programming"><div class="titlepage"><div><div><h3 class="title"><a name="d0e4655"></a> Functional programming </h3></div></div></div><p>To use these functions, you need to include: </p><p><code class="code">#include &lt;msm/front/euml/stl.hpp&gt;</code></p><p>or the specified header in the following tables.</p><p>The following table lists the supported STL algorithms: </p><p>
+ </p><div class="table"><a name="d0e4669"></a><p class="title"><b>Table&nbsp;2.&nbsp;STL algorithms</b></p><div class="table-contents"><table summary="STL algorithms" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL algorithms in querying.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>find_(first, last, value)</td><td>Find_</td></tr><tr><td>find_if_(first, last, value)</td><td>FindIf_</td></tr><tr><td>lower_bound_(first, last, value [,op&#7491;])</td><td>LowerBound_</td></tr><tr><td>upper_bound_(first, last, value [,op&#7491;])</td><td>UpperBound_</td></tr><tr><td>equal_range_(first, last, value [,op&#7491;])</td><td>EqualRange_</td></tr><tr><td>binary_search_(first, last, value [,op&#7491;])</td><td>BinarySearch_</td></tr><tr><td>min_element_(first, last[,op&#7491;])</td><td>MinElement_</td></tr><tr><td>max_element_(first, last[,op&#7491;])</td><td>MaxElement_</td></tr><tr><td>adjacent_find_(first, last[,op&#7491;])</td><td>AdjacentFind_</td></tr><tr><td>find_end_( first1, l
ast1, first2, last2 [,op &#7491;])</td><td>FindEnd_</td></tr><tr><td>find_first_of_( first1, last1, first2, last2 [,op &#7491;])</td><td>FindFirstOf_</td></tr><tr><td>equal_( first1, last1, first2 [,op &#7491;])</td><td>Equal_</td></tr><tr><td>search_( first1, last1, first2, last2 [,op &#7491;])</td><td>Search_</td></tr><tr><td>includes_( first1, last1, first2, last2 [,op &#7491;])</td><td>Includes_</td></tr><tr><td>lexicographical_compare_ ( first1, last1, first2, last2 [,op
+ &#7491;]) </td><td>LexicographicalCompare_</td></tr><tr><td>count_(first, last, value [,size])</td><td>Count_</td></tr><tr><td>count_if_(first, last, op &#7491; [,size])</td><td>CountIf_</td></tr><tr><td>distance_(first, last)</td><td>Distance_</td></tr><tr><td>mismatch _( first1, last1, first2 [,op &#7491;])</td><td>Mismatch_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e4780"></a><p class="title"><b>Table&nbsp;3.&nbsp;STL algorithms</b></p><div class="table-contents"><table summary="STL algorithms" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL algorithms in transformation.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>copy_(first, last, result)</td><td>Copy_</td></tr><tr><td>copy_backward_(first, last, result)</td><td>CopyBackward_</td></tr><tr><td>reverse_(first, last)</td><td>Reverse_</td></tr><tr><td>reverse_copy_(first, last , result)</td><td>ReverseCopy_</td></tr><tr><td>remove_(first, last, value)</td><td>Remove_</td></tr><tr><td>remove_if_(first, last , op&#7491;)</td><td>RemoveIf_</td></tr><tr><td>remove_copy_(first, last , output, value)</td><td>RemoveCopy_</td></tr><tr><td>remove_copy_if_(first, last, output, op&#7491;)</td><td>RemoveCopyIf_</td></tr><tr><td>fill_(first, last, value)</td><td>Fill_</td></tr><tr><td>fill_n_(first, size, value)&#7495;</td><td>FillN_</td></tr><tr><td>generate_(fir
st, last, generator&#7491;)</td><td>Generate_</td></tr><tr><td>generate_(first, size, generator&#7491;)&#7495;</td><td>GenerateN_</td></tr><tr><td>unique_(first, last [,op&#7491;])</td><td>Unique_</td></tr><tr><td>unique_copy_(first, last, output [,op&#7491;])</td><td>UniqueCopy_</td></tr><tr><td>random_shuffle_(first, last [,op&#7491;])</td><td>RandomShuffle_</td></tr><tr><td>rotate_copy_(first, middle, last, output)</td><td>RotateCopy_</td></tr><tr><td>partition_ (first, last [,op&#7491;])</td><td>Partition_</td></tr><tr><td>stable_partition_ (first, last [,op&#7491;])</td><td>StablePartition_</td></tr><tr><td>stable_sort_(first, last [,op&#7491;])</td><td>StableSort_</td></tr><tr><td>sort_(first, last [,op&#7491;])</td><td>Sort_</td></tr><tr><td>partial_sort_(first, middle, last [,op&#7491;])</td><td>PartialSort_</td></tr><tr><td>partial_sort_copy_ (first, last, res_first, res_last [,op&#7491;]) </td><td>PartialSortCopy_</td></tr><tr><td>nth_element_(first, nth, last [,op&#7491;])</td><td>NthElement_</td>
</tr><tr><td>merge_( first1, last1, first2, last2, output [,op &#7491;])</td><td>Merge_</td></tr><tr><td>inplace_merge_(first, middle, last [,op&#7491;])</td><td>InplaceMerge_</td></tr><tr><td>set_union_(first1, last1, first2, last2, output [,op
+ &#7491;])</td><td>SetUnion_</td></tr><tr><td>push_heap_(first, last [,op &#7491;])</td><td>PushHeap_</td></tr><tr><td>pop_heap_(first, last [,op &#7491;])</td><td>PopHeap_</td></tr><tr><td>make_heap_(first, last [,op &#7491;])</td><td>MakeHeap_</td></tr><tr><td>sort_heap_(first, last [,op &#7491;])</td><td>SortHeap_</td></tr><tr><td>next_permutation_(first, last [,op &#7491;])</td><td>NextPermutation_</td></tr><tr><td>prev_permutation_(first, last [,op &#7491;])</td><td>PrevPermutation_</td></tr><tr><td>inner_product_(first1, last1, first2, init [,op1&#7491;] [,op2&#7491;]) </td><td>InnerProduct_</td></tr><tr><td>partial_sum_(first, last, output [,op&#7491;])</td><td>PartialSum_</td></tr><tr><td>adjacent_difference_(first, last, output [,op&#7491;])</td><td>AdjacentDifference_</td></tr><tr><td>replace_(first, last, old_value, new_value)</td><td>Replace_</td></tr><tr><td>replace_if_(first, last, op&#7491;, new_value)</td><td>ReplaceIf_</td></tr><tr><td>replace_copy_(first,
 last, result, old_value,
+ new_value)</td><td>ReplaceCopy_</td></tr><tr><td>replace_copy_if_(first, last, result, op&#7491;, new_value)</td><td>ReplaceCopyIf_</td></tr><tr><td>rotate_(first, middle, last)&#7495;</td><td>Rotate_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e4996"></a><p class="title"><b>Table&nbsp;4.&nbsp;STL container methods</b></p><div class="table-contents"><table summary="STL container methods" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL container methods(common) in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>container::reference front_(container)</td><td>Front_</td></tr><tr><td>container::reference back_(container)</td><td>Back_</td></tr><tr><td>container::iterator begin_(container)</td><td>Begin_</td></tr><tr><td>container::iterator end_(container)</td><td>End_</td></tr><tr><td>container::reverse_iterator rbegin_(container)</td><td>RBegin_</td></tr><tr><td>container::reverse_iterator rend_(container)</td><td>REnd_</td></tr><tr><td>void push_back_(container, value)</td><td>Push_Back_</td></tr><tr><td>void pop_back_(container, value)</td><td>Pop_Back_</td></tr><tr><td>void push_front_(container, value)</td><td>Push_Front_</td></tr><tr><td>void pop_front_(container, value
)</td><td>Pop_Front_</td></tr><tr><td>void clear_(container)</td><td>Clear_</td></tr><tr><td>size_type capacity_(container)</td><td>Capacity_</td></tr><tr><td>size_type size_(container)</td><td>Size_</td></tr><tr><td>size_type max_size_(container)</td><td>Max_Size_</td></tr><tr><td>void reserve_(container, value)</td><td>Reserve _</td></tr><tr><td>void resize_(container, value)</td><td>Resize _</td></tr><tr><td>iterator insert_(container, pos, value)</td><td>Insert_</td></tr><tr><td>void insert_( container , pos, first, last)</td><td>Insert_</td></tr><tr><td>void insert_( container , pos, number, value)</td><td>Insert_</td></tr><tr><td>void swap_( container , other_container)</td><td>Swap_</td></tr><tr><td>void erase_( container , pos)</td><td>Erase_</td></tr><tr><td>void erase_( container , first, last) </td><td>Erase_</td></tr><tr><td>bool empty_( container)</td><td>Empty_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5127"></a><p class="title"><b>Table&nbsp;5.&nbsp;STL list methods</b></p><div class="table-contents"><table summary="STL list methods" border="1"><colgroup><col><col></colgroup><thead><tr><th>std::list methods in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>void list_remove_(container, value)</td><td>ListRemove_</td></tr><tr><td>void list_remove_if_(container, op&#7491;)</td><td>ListRemove_If_</td></tr><tr><td>void list_merge_(container, other_list)</td><td>ListMerge_</td></tr><tr><td>void list_merge_(container, other_list, op&#7491;)</td><td>ListMerge_</td></tr><tr><td>void splice_(container, iterator, other_list)</td><td>Splice_</td></tr><tr><td>void splice_(container, iterator, other_list,
+ iterator)</td><td>Splice_</td></tr><tr><td>void splice_(container, iterator, other_list, first,
+ last)</td><td>Splice_</td></tr><tr><td>void list_reverse_(container)</td><td>ListReverse_</td></tr><tr><td>void list_unique_(container)</td><td>ListUnique_</td></tr><tr><td>void list_unique_(container, op&#7491;)</td><td>ListUnique_</td></tr><tr><td>void list_sort_(container)</td><td>ListSort_</td></tr><tr><td>void list_sort_(container, op&#7491;)</td><td>ListSort_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5203"></a><p class="title"><b>Table&nbsp;6.&nbsp;STL associative container methods </b></p><div class="table-contents"><table summary="STL associative container methods " border="1"><colgroup><col><col></colgroup><thead><tr><th>Associative container methods in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>iterator insert_(container, pos, value)</td><td>Insert_</td></tr><tr><td>void insert_( container , first, last)</td><td>Insert_</td></tr><tr><td>pair&lt;iterator, bool&gt; insert_( container , value)</td><td>Insert_</td></tr><tr><td>void associative_erase_( container , pos)</td><td>Associative_Erase_</td></tr><tr><td>void associative_erase_( container , first, last)</td><td>Associative_Erase_</td></tr><tr><td>size_type associative_erase_( container , key)</td><td>Associative_Erase_</td></tr><tr><td>iterator associative_find_( container , key)</td><td>Associative_Find_</td></tr><tr><td>size_type associative_count_( container , key)</td><td>A
ssociativeCount_</td></tr><tr><td>iterator associative_lower_bound_( container , key)</td><td>Associative_Lower_Bound_</td></tr><tr><td>iterator associative_upper_bound_( container , key)</td><td>Associative_Upper_Bound_</td></tr><tr><td>pair&lt;iterator, iterator&gt; associative_equal_range_(
+ container , key)</td><td>Associative_Equal_Range_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5274"></a><p class="title"><b>Table&nbsp;7.&nbsp;STL pair</b></p><div class="table-contents"><table summary="STL pair" border="1"><colgroup><col><col></colgroup><thead><tr><th>std::pair in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>first_type first_(pair&lt;T1, T2&gt;)</td><td>First_</td></tr><tr><td>second_type second_(pair&lt;T1, T2&gt;)</td><td>Second_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5300"></a><p class="title"><b>Table&nbsp;8.&nbsp;STL string</b></p><div class="table-contents"><table summary="STL string" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>STL string method</th><th>std::string method in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>substr (size_type pos, size_type size)</td><td>string substr_(container, pos, length)</td><td>Substr_</td></tr><tr><td>int compare(string)</td><td>int string_compare_(container, another_string)</td><td>StringCompare_</td></tr><tr><td>int compare(char*)</td><td>int string_compare_(container, another_string)</td><td>StringCompare_</td></tr><tr><td>int compare(size_type pos, size_type size, string)</td><td>int string_compare_(container, pos, size,
+ another_string)</td><td>StringCompare_</td></tr><tr><td>int compare (size_type pos, size_type size, string, size_type
+ length)</td><td>int string_compare_(container, pos, size, another_string,
+ length)</td><td>StringCompare_</td></tr><tr><td>string&amp; append(const string&amp;)</td><td>string&amp; append_(container, another_string)</td><td>Append_</td></tr><tr><td>string&amp; append (charT*)</td><td>string&amp; append_(container, another_string)</td><td>Append_</td></tr><tr><td>string&amp; append (string , size_type pos, size_type
+ size)</td><td>string&amp; append_(container, other_string, pos,
+ size)</td><td>Append_</td></tr><tr><td>string&amp; append (charT*, size_type size)</td><td>string&amp; append_(container, another_string,
+ length)</td><td>Append_</td></tr><tr><td>string&amp; append (size_type size, charT)</td><td>string&amp; append_(container, size, char)</td><td>Append_</td></tr><tr><td>string&amp; append (iterator begin, iterator end)</td><td>string&amp; append_(container, begin, end)</td><td>Append_</td></tr><tr><td>string&amp; insert (size_type pos, charT*)</td><td>string&amp; string_insert_(container, pos,
+ other_string)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert(size_type pos, charT*,size_type n)</td><td>string&amp; string_insert_(container, pos, other_string,
+ n)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert(size_type pos,size_type n, charT
+ c)</td><td>string&amp; string_insert_(container, pos, n, c)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert (size_type pos, const string&amp;)</td><td>string&amp; string_insert_(container, pos,
+ other_string)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert (size_type pos, const string&amp;,
+ size_type pos1, size_type n)</td><td>string&amp; string_insert_(container, pos, other_string,
+ pos1, n)</td><td>StringInsert_</td></tr><tr><td>string&amp; erase(size_type pos=0, size_type n=npos)</td><td>string&amp; string_erase_(container, pos, n)</td><td>StringErase_</td></tr><tr><td>string&amp; assign(const string&amp;)</td><td>string&amp; string_assign_(container, another_string)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const charT*)</td><td>string&amp; string_assign_(container, another_string)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const string&amp;, size_type pos,
+ size_type n)</td><td>string&amp; string_assign_(container, another_string, pos,
+ n)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const charT*, size_type n)</td><td>string&amp; string_assign_(container, another_string,
+ n)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(size_type n, charT c)</td><td>string&amp; string_assign_(container, n, c)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(iterator first, iterator last)</td><td>string&amp; string_assign_(container, first, last)</td><td>StringAssign_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const
+ string&amp;)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const charT*,
+ size_type n1)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string, n1)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const
+ charT*)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, size_type n1,
+ charT c)</td><td>string&amp; string_replace_(container, pos, n, n1, c)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ string&amp;)</td><td>string&amp; string_replace_(container, first, last,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ charT*, size_type n)</td><td>string&amp; string_replace_(container, first, last,
+ another_string, n)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ charT*)</td><td>string&amp; string_replace_(container, first, last,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, size_type
+ n, charT c)</td><td>string&amp; string_replace_(container, first, last, n,
+ c)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, iterator
+ f, iterator l)</td><td>string&amp; string_replace_(container, first, last, f,
+ l)</td><td>StringReplace_</td></tr><tr><td>const charT* c_str()</td><td>const charT* c_str_(container)</td><td>CStr_</td></tr><tr><td>const charT* data()</td><td>const charT* string_data_(container)</td><td>StringData_</td></tr><tr><td>size_type copy(charT* buf, size_type n, size_type pos =
+ 0)</td><td>size_type string_copy_(container, buf, n, pos); size_type
+ string_copy_(container, buf, n) </td><td>StringCopy_</td></tr><tr><td>size_type find(charT* s, size_type pos, size_type n)</td><td>size_type string_find_(container, s, pos, n)</td><td>StringFind_</td></tr><tr><td>size_type find(charT* s, size_type pos=0)</td><td>size_type string_find_(container, s, pos); size_type
+ string_find_(container, s) </td><td>StringFind_</td></tr><tr><td>size_type find(const string&amp; s, size_type pos=0)</td><td>size_type string_find_(container, s, pos) size_type
+ string_find_(container, s) </td><td>StringFind_</td></tr><tr><td>size_type find(charT c, size_type pos=0)</td><td>size_type string_find_(container, c, pos) size_type
+ string_find_(container, c) </td><td>StringFind_</td></tr><tr><td>size_type rfind(charT* s, size_type pos, size_type n)</td><td>size_type string_rfind_(container, s, pos, n)</td><td>StringRFind_</td></tr><tr><td>size_type rfind(charT* s, size_type pos=npos)</td><td>size_type string_rfind_(container, s, pos); size_type
+ string_rfind_(container, s) </td><td>StringRFind_</td></tr><tr><td>size_type rfind(const string&amp; s, size_type
+ pos=npos)</td><td>size_type string_rfind_(container, s, pos); size_type
+ string_rfind_(container, s) </td><td>StringRFind_</td></tr><tr><td>size_type rfind(charT c, size_type pos=npos)</td><td>size_type string_rfind_(container, c, pos) size_type
+ string_rfind_(container, c) </td><td>StringRFind_</td></tr><tr><td>size_type find_first_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_first_of_(container, s, pos, n)</td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (charT* s, size_type pos=0)</td><td>size_type find_first_of_(container, s, pos); size_type
+ find_first_of_(container, s) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (const string&amp; s, size_type
+ pos=0)</td><td>size_type find_first_of_(container, s, pos); size_type
+ find_first_of_(container, s) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (charT c, size_type pos=0)</td><td>size_type find_first_of_(container, c, pos) size_type
+ find_first_of_(container, c) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_not_of(charT* s, size_type pos,
+ size_type n)</td><td>size_type find_first_not_of_(container, s, pos, n)</td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (charT* s, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, s, pos); size_type
+ find_first_not_of_(container, s) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (const string&amp; s, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, s, pos); size_type
+ find_first_not_of_(container, s) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (charT c, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, c, pos); size_type
+ find_first_not_of_(container, c) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_last_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_last_of_(container, s, pos, n)</td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (charT* s, size_type pos=npos)</td><td>size_type find_last_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (const string&amp; s, size_type
+ pos=npos)</td><td>size_type find_last_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (charT c, size_type pos=npos)</td><td>size_type find_last_of_(container, c, pos); size_type
+ find_last_of_(container, c) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_not_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_last_not_of_(container, s, pos, n)</td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (charT* s, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (const string&amp; s, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, s, pos); size_type
+ find_last_not_of_(container, s) </td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (charT c, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, c, pos); size_type
+ find_last_not_of_(container, c) </td><td>StringFindLastNotOf_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p><span class="underline">Notes</span>: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>&#7491;: algorithms requiring a predicate need to make them eUML compatible
+ by wrapping them inside a Predicate_ functor. For example,
+ std::less&lt;int&gt; =&gt; Predicate_&lt;std::less&lt;int&gt; &gt;()</p></li><li class="listitem"><p>&#7495;: If using the SGI STL implementation, these functors use the SGI
+ return value</p></li></ul></div><p>
+ </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ar01s08.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;</td></tr><tr><td width="40%" align="left" valign="top">Acknowledgements&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/boost.css
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/boost.css 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,66 @@
+/*=============================================================================
+ Copyright 2002 William E. Kempf
+ Distributed under the Boost Software License, Version 1.0. (See accompany-
+ ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+H1
+{
+ FONT-SIZE: 200%;
+ COLOR: #00008B;
+}
+H2
+{
+ FONT-SIZE: 150%;
+}
+H3
+{
+ FONT-SIZE: 125%;
+}
+H4
+{
+ FONT-SIZE: 108%;
+}
+BODY
+{
+ FONT-SIZE: 100%;
+ BACKGROUND-COLOR: #ffffff;
+ COLOR: #000000;
+}
+PRE
+{
+ MARGIN-LEFT: 2em;
+ FONT-FAMILY: Courier,
+ monospace;
+}
+CODE
+{
+ FONT-FAMILY: Courier,
+ monospace;
+}
+CODE.as_pre
+{
+ white-space: pre;
+}
+.index
+{
+ TEXT-ALIGN: left;
+}
+.page-index
+{
+ TEXT-ALIGN: left;
+}
+.definition
+{
+ TEXT-ALIGN: left;
+}
+.footnote
+{
+ FONT-SIZE: 66%;
+ VERTICAL-ALIGN: super;
+ TEXT-DECORATION: none;
+}
+.function-semantics
+{
+ CLEAR: left;
+}
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/boostbook.css
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/boostbook.css 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,594 @@
+/*=============================================================================
+ Copyright (c) 2004 Joel de Guzman
+ http://spirit.sourceforge.net/
+
+ Distributed under the Boost Software License, Version 1.0. (See accompany-
+ ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+/*=============================================================================
+ Body defaults
+=============================================================================*/
+
+ body
+ {
+ margin: 1em;
+ font-family: sans-serif;
+ }
+
+/*=============================================================================
+ Paragraphs
+=============================================================================*/
+
+ p
+ {
+ text-align: left;
+ font-size: 10pt;
+ line-height: 1.15;
+ }
+
+/*=============================================================================
+ Program listings
+=============================================================================*/
+
+ /* Code on paragraphs */
+ p tt.computeroutput
+ {
+ font-size: 9pt;
+ }
+
+ pre.synopsis
+ {
+ font-size: 90%;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ .programlisting,
+ .screen
+ {
+ font-size: 9pt;
+ display: block;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ /* Program listings in tables don't get borders */
+ td .programlisting,
+ td .screen
+ {
+ margin: 0pc 0pc 0pc 0pc;
+ padding: 0pc 0pc 0pc 0pc;
+ }
+
+/*=============================================================================
+ Headings
+=============================================================================*/
+
+ h1, h2, h3, h4, h5, h6
+ {
+ text-align: left;
+ margin: 1em 0em 0.5em 0em;
+ font-weight: bold;
+ }
+
+ h1 { font: 140% }
+ h2 { font: bold 140% }
+ h3 { font: bold 130% }
+ h4 { font: bold 120% }
+ h5 { font: italic 110% }
+ h6 { font: italic 100% }
+
+ /* Top page titles */
+ title,
+ h1.title,
+ h2.title
+ h3.title,
+ h4.title,
+ h5.title,
+ h6.title,
+ .refentrytitle
+ {
+ font-weight: bold;
+ margin-bottom: 1pc;
+ }
+
+ h1.title { font-size: 140% }
+ h2.title { font-size: 140% }
+ h3.title { font-size: 130% }
+ h4.title { font-size: 120% }
+ h5.title { font-size: 110% }
+ h6.title { font-size: 100% }
+
+ .section h1
+ {
+ margin: 0em 0em 0.5em 0em;
+ font-size: 140%;
+ }
+
+ .section h2 { font-size: 140% }
+ .section h3 { font-size: 130% }
+ .section h4 { font-size: 120% }
+ .section h5 { font-size: 110% }
+ .section h6 { font-size: 100% }
+
+ /* Code on titles */
+ h1 tt.computeroutput { font-size: 140% }
+ h2 tt.computeroutput { font-size: 140% }
+ h3 tt.computeroutput { font-size: 130% }
+ h4 tt.computeroutput { font-size: 120% }
+ h5 tt.computeroutput { font-size: 110% }
+ h6 tt.computeroutput { font-size: 100% }
+
+/*=============================================================================
+ Author
+=============================================================================*/
+
+ h3.author
+ {
+ font-size: 100%
+ }
+
+/*=============================================================================
+ Lists
+=============================================================================*/
+
+ li
+ {
+ font-size: 10pt;
+ line-height: 1.3;
+ }
+
+ /* Unordered lists */
+ ul
+ {
+ text-align: left;
+ }
+
+ /* Ordered lists */
+ ol
+ {
+ text-align: left;
+ }
+
+/*=============================================================================
+ Links
+=============================================================================*/
+
+ a
+ {
+ text-decoration: none; /* no underline */
+ }
+
+ a:hover
+ {
+ text-decoration: underline;
+ }
+
+/*=============================================================================
+ Spirit style navigation
+=============================================================================*/
+
+ .spirit-nav
+ {
+ text-align: right;
+ }
+
+ .spirit-nav a
+ {
+ color: white;
+ padding-left: 0.5em;
+ }
+
+ .spirit-nav img
+ {
+ border-width: 0px;
+ }
+
+/*=============================================================================
+ Copyright footer
+=============================================================================*/
+ .copyright-footer
+ {
+ text-align: right;
+ font-size: 70%;
+ }
+
+ .copyright-footer p
+ {
+ text-align: right;
+ font-size: 80%;
+ }
+
+/*=============================================================================
+ Table of contents
+=============================================================================*/
+
+ .toc
+ {
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.1pc 1pc 0.1pc 1pc;
+ font-size: 80%;
+ line-height: 1.15;
+ }
+
+ .boost-toc
+ {
+ float: right;
+ padding: 0.5pc;
+ }
+
+/*=============================================================================
+ Tables
+=============================================================================*/
+
+ .table-title,
+ div.table p.title
+ {
+ margin-left: 4%;
+ padding-right: 0.5em;
+ padding-left: 0.5em;
+ }
+
+ .informaltable table,
+ .table table
+ {
+ width: 92%;
+ margin-left: 4%;
+ margin-right: 4%;
+ }
+
+ div.informaltable table,
+ div.table table
+ {
+ padding: 4px;
+ }
+
+ /* Table Cells */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ padding: 0.5em;
+ text-align: left;
+ font-size: 9pt;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ padding: 0.5em 0.5em 0.5em 0.5em;
+ border: 1pt solid white;
+ font-size: 80%;
+ }
+
+ table.simplelist
+ {
+ width: auto !important;
+ margin: 0em !important;
+ padding: 0em !important;
+ border: none !important;
+ }
+ table.simplelist td
+ {
+ margin: 0em !important;
+ padding: 0em !important;
+ text-align: left !important;
+ font-size: 9pt !important;
+ border: none !important;
+ }
+
+/*=============================================================================
+ Blurbs
+=============================================================================*/
+
+ div.note,
+ div.tip,
+ div.important,
+ div.caution,
+ div.warning,
+ p.blurb
+ {
+ font-size: 9pt; /* A little bit smaller than the main text */
+ line-height: 1.2;
+ display: block;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ p.blurb img
+ {
+ padding: 1pt;
+ }
+
+/*=============================================================================
+ Variable Lists
+=============================================================================*/
+
+ div.variablelist
+ {
+ margin: 1em 0;
+ }
+
+ /* Make the terms in definition lists bold */
+ div.variablelist dl dt,
+ span.term
+ {
+ font-weight: bold;
+ font-size: 10pt;
+ }
+
+ div.variablelist table tbody tr td
+ {
+ text-align: left;
+ vertical-align: top;
+ padding: 0em 2em 0em 0em;
+ font-size: 10pt;
+ margin: 0em 0em 0.5em 0em;
+ line-height: 1;
+ }
+
+ div.variablelist dl dt
+ {
+ margin-bottom: 0.2em;
+ }
+
+ div.variablelist dl dd
+ {
+ margin: 0em 0em 0.5em 2em;
+ font-size: 10pt;
+ }
+
+ div.variablelist table tbody tr td p,
+ div.variablelist dl dd p
+ {
+ margin: 0em 0em 0.5em 0em;
+ line-height: 1;
+ }
+
+/*=============================================================================
+ Misc
+=============================================================================*/
+
+ /* Title of books and articles in bibliographies */
+ span.title
+ {
+ font-style: italic;
+ }
+
+ span.underline
+ {
+ text-decoration: underline;
+ }
+
+ span.strikethrough
+ {
+ text-decoration: line-through;
+ }
+
+ /* Copyright, Legal Notice */
+ div div.legalnotice p
+ {
+ text-align: left
+ }
+
+/*=============================================================================
+ Colors
+=============================================================================*/
+
+ @media screen
+ {
+ body {
+ background-color: #FFFFFF;
+ color: #000000;
+ }
+
+ /* Links */
+ a
+ {
+ color: #005a9c;
+ }
+
+ a:visited
+ {
+ color: #9c5a9c;
+ }
+
+ h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
+ h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
+ h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
+ {
+ text-decoration: none; /* no underline */
+ color: #000000;
+ }
+
+ /* Syntax Highlighting */
+ .keyword { color: #0000AA; }
+ .identifier { color: #000000; }
+ .special { color: #707070; }
+ .preprocessor { color: #402080; }
+ .char { color: teal; }
+ .comment { color: #800000; }
+ .string { color: teal; }
+ .number { color: teal; }
+ .white_bkd { background-color: #FFFFFF; }
+ .dk_grey_bkd { background-color: #999999; }
+
+ /* Copyright, Legal Notice */
+ .copyright
+ {
+ color: #666666;
+ font-size: small;
+ }
+
+ div div.legalnotice p
+ {
+ color: #666666;
+ }
+
+ /* Program listing */
+ pre.synopsis
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ .programlisting,
+ .screen
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ td .programlisting,
+ td .screen
+ {
+ border: 0px solid #DCDCDC;
+ }
+
+ /* Blurbs */
+ div.note,
+ div.tip,
+ div.important,
+ div.caution,
+ div.warning,
+ p.blurb
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ /* Table of contents */
+ .toc
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ /* Tables */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ background-color: #F0F0F0;
+ border: 1px solid #DCDCDC;
+ }
+
+ .copyright-footer
+ {
+ color: #8F8F8F;
+ }
+
+ /* Misc */
+ span.highlight
+ {
+ color: #00A000;
+ }
+ }
+
+ @media print
+ {
+ /* Links */
+ a
+ {
+ color: black;
+ }
+
+ a:visited
+ {
+ color: black;
+ }
+
+ .spirit-nav
+ {
+ display: none;
+ }
+
+ /* Program listing */
+ pre.synopsis
+ {
+ border: 1px solid gray;
+ }
+
+ .programlisting,
+ .screen
+ {
+ border: 1px solid gray;
+ }
+
+ td .programlisting,
+ td .screen
+ {
+ border: 0px solid #DCDCDC;
+ }
+
+ /* Table of contents */
+ .toc
+ {
+ border: 1px solid gray;
+ }
+
+ .informaltable table,
+ .table table
+ {
+ border: 1px solid gray;
+ border-collapse: collapse;
+ }
+
+ /* Tables */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ border: 1px solid gray;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ border: 1px solid gray;
+ }
+
+ table.simplelist tr td
+ {
+ border: none !important;
+ }
+
+ /* Misc */
+ span.highlight
+ {
+ font-weight: bold;
+ }
+ }
+
+/*=============================================================================
+ Images
+=============================================================================*/
+
+ span.inlinemediaobject img
+ {
+ vertical-align: middle;
+ }
+
+/*==============================================================================
+ Super and Subscript: style so that line spacing isn't effected, see
+ http://www.adobe.com/cfusion/communityengine/index.cfm?event=showdetails&productId=1&postId=5341
+==============================================================================*/
+
+sup,
+sub {
+ height: 0;
+ line-height: 1;
+ vertical-align: baseline;
+ _vertical-align: bottom;
+ position: relative;
+
+}
+
+sup {
+ bottom: 1ex;
+}
+
+sub {
+ top: .5ex;
+}
+

Added: sandbox/msm/libs/msm/doc/HTML/ch01.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch01.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,23 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;1.&nbsp;Founding idea</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="prev" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="next" href="ch02.html" title="Chapter&nbsp;2.&nbsp;UML Short Guide"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;1.&nbsp;Founding idea</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="pt01.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;I.&nbsp;User' guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;1.&nbsp;Fo
unding idea"><div class="titlepage"><div><div><h2 class="title"><a name="d0e99"></a>Chapter&nbsp;1.&nbsp;Founding idea</h2></div></div></div><p>Let's start with an example taken from the C++ Template Metaprogramming
+ book:</p><p>
+ <code class="code">class player : public state_machine&lt;player&gt;</code></p><p><code class="code">{ </code></p><p><code class="code">// The list of FSM states enum states { Empty, Open, Stopped, Playing,
+ Paused , initial_state = Empty }; </code></p><p><code class="code">// transition actions void start_playback(play const&amp;) { std::cout
+ &lt;&lt; "player::start_playback\n"; } </code></p><p><code class="code">void open_drawer(open_close const&amp;) { std::cout &lt;&lt;
+ "player::open_drawer\n"; } </code></p><p><code class="code">void close_drawer(open_close const&amp;) { std::cout &lt;&lt;
+ "player::close_drawer\n"; } </code></p><p><code class="code">void store_cd_info(cd_detected const&amp;) { std::cout &lt;&lt;
+ "player::store_cd_info\n"; } </code></p><p><code class="code">void stop_playback(stop const&amp;) { std::cout &lt;&lt;
+ "player::stop_playback\n"; } </code></p><p><code class="code">void pause_playback(pause const&amp;) { std::cout &lt;&lt;
+ "player::pause_playback\n"; } </code></p><p><code class="code">void resume_playback(play const&amp;) { std::cout &lt;&lt;
+ "player::resume_playback\n"; } </code></p><p><code class="code">void stop_and_open(open_close const&amp;) { std::cout &lt;&lt;
+ "player::stop_and_open\n"; } </code></p><p><code class="code">friend class state_machine&lt;player&gt;; </code></p><p><code class="code">typedef player p; // makes transition table cleaner </code></p><p><code class="code">// Transition table </code></p><p><code class="code">struct transition_table : mpl::vector11&lt; </code></p><p><code class="code">row &lt; Stopped , play , Playing , &amp;p::start_playback &gt;, </code></p><p><code class="code">row &lt; Stopped , open_close , Open , &amp;p::open_drawer &gt;, </code></p><p><code class="code">row &lt; Open , open_close , Empty , &amp;p::close_drawer &gt;, </code></p><p><code class="code">row &lt; Empty , open_close , Open , &amp;p::open_drawer &gt;, </code></p><p><code class="code">row &lt; Empty , cd_detected , Stopped , &amp;p::store_cd_info &gt;,
+ </code></p><p><code class="code">row &lt; Playing , stop , Stopped , &amp;p::stop_playback &gt;, </code></p><p><code class="code">row &lt; Playing , pause , Paused , &amp;p::pause_playback &gt;, </code></p><p><code class="code">row &lt; Playing , open_close , Open , &amp;p::stop_and_open &gt;,
+ </code></p><p><code class="code">row &lt; Paused , play , Playing , &amp;p::resume_playback &gt;, </code></p><p><code class="code">row &lt; Paused , stop , Stopped , &amp;p::stop_playback &gt;, </code></p><p><code class="code">row &lt; Paused , open_close , Open , &amp;p::stop_and_open &gt; </code></p><p><code class="code">&gt; {}; </code></p><p><code class="code">// Replaces the default no-transition response. </code></p><p><code class="code">template &lt;class Event&gt; int no_transition(int state, Event const&amp; e) {
+ std::cout &lt;&lt; "no transition from state " &lt;&lt; state &lt;&lt; " on
+ event " &lt;&lt; typeid(e).name() &lt;&lt; std::endl; return state; } };</code>
+ </p><p><code class="code">void test() { player p; p.process_event(open_close());...}</code></p><p>This example is the foundation for the idea driving MSM: a descriptive and
+ expressive language based on a transition table with as little syntactic noise as
+ possible, all this while offering as many features from the UML 2.0 standard as
+ possible. MSM also offers several expressive state machine definition syntaxes with
+ different trade-offs.</p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="pt01.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Part&nbsp;I.&nbsp;User' guide&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;2.&nbsp;UML Short Guide</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch02.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch02.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,9 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;2.&nbsp;UML Short Guide</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="prev" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Founding idea"><link rel="next" href="ch02s02.html" title="Concepts"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;2.&nbsp;UML Short Guide</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch01.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;I.&nbsp;User' guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;2.&nbsp;UML Short Guide
"><div class="titlepage"><div><div><h2 class="title"><a name="d0e198"></a>Chapter&nbsp;2.&nbsp;UML Short Guide</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1">What are state machines?</span></dt><dt><span class="sect1">Concepts</span></dt><dd><dl><dt><span class="sect2">State machine, state, transition, event </span></dt><dt><span class="sect2">Submachines, orthogonal regions, pseudostates </span></dt><dt><span class="sect2"><a href="ch02s02.html#d0e284">
+ History </a></span></dt><dt><span class="sect2"><a href="ch02s02.html#d0e298">Completion transitions / anonymous
+ transitions</a></span></dt><dt><span class="sect2"> Internal transitions </span></dt><dt><span class="sect2"><a href="ch02s02.html#d0e316">
+ Conflicting transitions </a></span></dt></dl></dd><dt><span class="sect1">State machine glossary</span></dt></dl></div><div class="sect1" title="What are state machines?"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e201"></a>What are state machines?</h2></div></div></div><p>State machines are the description of a thing's lifeline. They describe the
+ different stages of the lifeline, the events influencing it, and what it does
+ when a particular event is detected at a particular stage. They offer the
+ complete specification of the dynamic behavior of the thing.</p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch01.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;1.&nbsp;Founding idea&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Concepts</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch02s02.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch02s02.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,98 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Concepts</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;UML Short Guide"><link rel="prev" href="ch02.html" title="Chapter&nbsp;2.&nbsp;UML Short Guide"><link rel="next" href="ch02s03.html" title="State machine glossary"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Concepts</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;UML Short Guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Concepts"><div class="titlepage"><div><div><h2 class="title" sty
le="clear: both"><a name="d0e206"></a>Concepts</h2></div></div></div><p>Thinking in terms of state machines is a bit surprising at first, so let us
+ have a quick glance at the concepts.</p><div class="sect2" title="State machine, state, transition, event"><div class="titlepage"><div><div><h3 class="title"><a name="d0e211"></a>State machine, state, transition, event </h3></div></div></div><p>A state machine is a concrete model describing the behavior of a system.
+ It is composed of a finite number of states and transitions.</p><p>
+ <span class="inlinemediaobject"><img src="../images/sm.gif"></span></p><p>A simple state has no sub states. It can have data, entry and exit
+ behaviors and deferred events. One can provide entry and exit behaviors
+ (also called actions) to states (or state machines), which are executed
+ whenever a state is entered or left, no matter how. A state can also have
+ internal transitions which cause no entry or exit behavior to be called. A
+ state can mark events as deferred. This means the event cannot be processed
+ if this state is active, but it must be retained. Next time a state not
+ deferring this event is active, the event will be processed, as if it had
+ just been fired. </p><p><span class="inlinemediaobject"><img src="../images/state.gif"></span></p><p>A transition is the switching between active states, triggered by an
+ event. Actions and guard conditions can be attached to the transition. The
+ action executes when the transition fires, the guard is a Boolean operation
+ executed first and which can prevent the transition from firing by returning
+ false.</p><p>
+ <span class="inlinemediaobject"><img src="../images/transition.jpg"></span></p><p>An initial state marks the first active state of a state machine. It has
+ no real existence and neither has the transition originating from it.</p><p>
+ <span class="inlinemediaobject"><img src="../images/init_state.gif"></span></p></div><div class="sect2" title="Submachines, orthogonal regions, pseudostates"><div class="titlepage"><div><div><h3 class="title"><a name="d0e241"></a>Submachines, orthogonal regions, pseudostates </h3></div></div></div><p>A composite state is a state containing a region or decomposed in two or
+ more regions. A composite state contains its own set of states and regions. </p><p>A submachine is a state machine inserted as a state in another state
+ machine. The same submachine can be inserted more than once. </p><p>Orthogonal regions are parts of a composite state or submachine, each
+ having its own set of mutually exclusive set of states and transitions. </p><p><span class="inlinemediaobject"><img src="../images/regions.gif" width="60%"></span></p><p>UML also defines a number of pseudo states, which are considered important
+ concepts to model, but not enough to make them first-class citizens. The
+ terminate pseudo state terminates the execution of a state machine (MSM
+ handles this slightly differently. The state machine is not destroyed but no
+ further event processing occurs.). </p><p><span class="inlinemediaobject"><img src="../images/terminate.gif"></span></p><p>An exit point pseudo state exits a composite state or a submachine and
+ forces termination of execution in all contained regions.</p><p><span class="inlinemediaobject"><img src="../images/exit.gif" width="60%"></span></p><p>An entry point pseudo state allows a kind of controlled entry inside a
+ composite. Precisely, it connects a transition outside the composite to a
+ transition inside the composite. An important point is that this mechanism
+ only allows a single region to be entered. In the above diagram, in region1,
+ the initial state would become active. </p><p><span class="inlinemediaobject"><img src="../images/entry_point.gif"></span></p><p>There are also two more ways to enter a submachine (apart the obvious and
+ more common case of a transition terminating on the submachine as shown in
+ the region case). An explicit entry means that an inside state is the target
+ of a transition. Unlike with direct entry, no tentative encapsulation is
+ made, and only one transition is executed. An explicit exit is a transition
+ from an inner state to a state outside the submachine (not supported by
+ MSM). I would not recommend using explicit entry or exit. </p><p><span class="inlinemediaobject"><img src="../images/explicit.gif"></span></p><p>The last entry possibility is using fork. A fork is an explicit entry into
+ one or more regions. Other regions are again activated using their initial
+ state. </p><p><span class="inlinemediaobject"><img src="../images/fork.gif" width="70%"></span></p></div><div class="sect2" title="History"><div class="titlepage"><div><div><h3 class="title"><a name="d0e284"></a>
+ <span class="command"><strong><a name="uml-history"></a></strong></span>History </h3></div></div></div><p>UML defines two kinds of history, shallow history and deep history.
+ Shallow history is a pseudo state representing the most recent substate of a
+ submachine. A submachine can have at most one shallow history. A transition
+ with a history pseudo state as target is equivalent to a transition with the
+ most recent substate as target. And very importantly, only one transition
+ may originate from the history. Deep history is a shallow history
+ recursively reactivating the substates of the most recent substate. It is
+ represented like the shallow history with a star (H* inside a
+ circle).</p><p>
+ <span class="inlinemediaobject"><img src="../images/history.gif" width="60%"></span></p><p>History is not a completely satisfying concept. First of all, there can be
+ just one history pseudo state and only one transition may originate from it.
+ So they do not mix well with orthogonal regions as only one region can be
+ &#8220;remembered&#8221;. Deep history is even worse and looks like a last-minute
+ addition. History has to be activated by a transition and only one
+ transition originates from it, so how to model the transition originating
+ from the deep history pseudo state and pointing to the most recent substate
+ of the substate? As a bonus, it is also inflexible and does not accept new
+ types of histories. Let's face it, history sounds great and is useful in
+ theory, but the UML version is not quite making the cut. And therefore, MSM
+ provides a different version of this useful concept. </p></div><div class="sect2" title="Completion transitions / anonymous transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e298"></a><span class="command"><strong><a name="uml-anonymous"></a></strong></span>Completion transitions / anonymous
+ transitions</h3></div></div></div><p>Completion events (or transitions), also called anonymous transitions, are
+ defined as transitions having no defined event triggering them. This means
+ that such transitions will immediately fire when a state being the source of
+ an anonymous transition becomes active, provided that a guard allows it.
+ They are useful in modeling algorithms as an activity diagram would normally
+ do. In the real-time world, they have the advantage of making it easier to
+ estimate how long a periodically executed action will last. For example,
+ consider the following diagram. </p><p><span class="inlinemediaobject"><img src="../images/completion.gif"></span></p><p>The designer now knows at any time that he will need a maximum of 4
+ transitions. Being able to estimate how long a transition takes, he can
+ estimate how much of a time frame he will need to require (real-time tasks
+ are often executed at regular intervals). If he can also estimate the
+ duration of actions, he can even use graph algorithms to better estimate his
+ timing requirements. </p></div><div class="sect2" title="Internal transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e310"></a><span class="command"><strong><a name="UML-internal-transition"></a></strong></span> Internal transitions </h3></div></div></div><p>Internal transitions are transitions executing in the scope of the active
+ state, being a simple state or a submachine. One can see them as a
+ self-transition of this state, without an entry or exit action
+ called.</p></div><div class="sect2" title="Conflicting transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e316"></a>
+ <span class="command"><strong><a name="transition-conflict"></a></strong></span>Conflicting transitions </h3></div></div></div><p>If, for a given event, several transitions are enabled, they are said to
+ be in conflict. There are two kinds of conflicts: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>For a given source state, several transitions are defined,
+ triggered by the same event. Normally, the guard condition in
+ each transition defines which one is fired.</p></li><li class="listitem"><p>The source state is a submachine or simple state and the
+ conflict is between a transition internal to this state and a
+ transition triggered by the same event and having as target
+ another state.</p></li></ul></div><p>The first one is simple; one only needs to define two or more
+ rows in the transition table, with the same source and trigger, with a
+ different guard condition. Beware, however, that the UML standard wants
+ these conditions to be not overlapping. If they do, the standard says
+ nothing except that this is incorrect, so the implementer is free to
+ implement it the way he sees fit. In the case of MSM, the transition
+ appearing last in the transition table gets selected first, if it returns
+ false (meaning disabled), the library tries with the previous one, and so
+ on.</p><p>
+ <span class="inlinemediaobject"><img src="../images/conflict1.gif"></span></p><p>In the second case, UML defines that the most inner transition gets
+ selected first, which makes sense, otherwise no exit point pseudo state
+ would be possible (the inner transition brings us to the exit point, from
+ where the containing state machine can take over). </p><p><span class="inlinemediaobject"><img src="../images/conflict2.gif" width="60%"></span></p><p>MSM handles both cases itself, so the designer needs only concentrate on
+ its state machine and the UML subtleties (not overlapping conditions), not
+ on implementing this behavior himself. </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;2.&nbsp;UML Short Guide&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;State machine glossary</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch02s03.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch02s03.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,37 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>State machine glossary</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;UML Short Guide"><link rel="prev" href="ch02s02.html" title="Concepts"><link rel="next" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Tutorial"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">State machine glossary</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;UML Short Guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="State machine glossary"><div class="titlepage"><div><div>
<h2 class="title" style="clear: both"><a name="d0e344"></a>State machine glossary</h2></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>state machine: the life cycle of a thing. It is made of states,
+ regions, transitions and processes incoming events.</p></li><li class="listitem"><p>state: a stage in the life cycle of a state machine. A state (like
+ a submachine) can have an entry and exit behaviors.</p></li><li class="listitem"><p>event: an incident provoking (or not) a reaction of the state
+ machine</p></li><li class="listitem"><p>transition: a specification of how a state machine reacts to an
+ event. It specifies a source state, the event triggering the
+ transition, the target state (which will become the newly active
+ state if the transition is triggered), guard and actions.</p></li><li class="listitem"><p>action: an operation executed during the triggering of the
+ transition.</p></li><li class="listitem"><p>guard: a boolean operation being able to prevent the triggering of
+ a transition which would otherwise fire.</p></li><li class="listitem"><p>transition table: representation of a state machine. A state
+ machine diagram is a graphical, but incomplete representation of the
+ same model. A transition table, on the other hand, is a complete
+ representation.</p></li><li class="listitem"><p>initial state: The state in which the state machine starts. Having
+ several orthogonal regions means having as many initial
+ states.</p></li><li class="listitem"><p>submachine: A submachine is a state machine inserted as a state in
+ another state machine and can be found several times in a same state
+ machine.</p></li><li class="listitem"><p>orthogonal regions: (logical) parallel flow of execution of a
+ state machine. Every region of a state machine gets a chance to
+ process an incoming event.</p></li><li class="listitem"><p>terminate pseudo-state: when this state becomes active, it
+ terminates the execution of the whole state machine. MSM does not
+ destroy the state machine as required by the UML standard, however,
+ which lets you keep all the state machine's data.</p></li><li class="listitem"><p>entry/exit pseudo state: defined for submachines and are defined
+ as a connection between a transition outside of the submachine and a
+ transition inside the submachine. It is a way to enter or leave a
+ submachine through a predefined point.</p></li><li class="listitem"><p>fork: a fork allows explicit entry into several orthogonal regions
+ of a submachine.</p></li><li class="listitem"><p>history: a history is a way to remember the active state of a
+ submachine so that the submachine can proceed in its last active
+ state next time it becomes active.</p></li><li class="listitem"><p>completion events (also called completion/anonymous transitions):
+ when a transition has no named event triggering it, it automatically
+ fires when the source state is active, unless a guard forbids
+ it.</p></li><li class="listitem"><p>transition conflict: a conflict is present if for a given source
+ state and incoming event, several transitions are possible. UML
+ specifies that guard conditions have to solve the conflict.</p></li><li class="listitem"><p>internal transitions: transition from a state to itself without
+ having exit and entry actions being called.</p></li></ul></div><p>
+ </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Concepts&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;3.&nbsp;Tutorial</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch03.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch03.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,18 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;3.&nbsp;Tutorial</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="prev" href="ch02s03.html" title="State machine glossary"><link rel="next" href="ch03s02.html" title="Basic front-end"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;3.&nbsp;Tutorial</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;I.&nbsp;User' guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;3.&nbsp;Tutorial"><div class="titlep
age"><div><div><h2 class="title"><a name="d0e402"></a>Chapter&nbsp;3.&nbsp;Tutorial</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1">Design</span></dt><dt><span class="sect1">Basic front-end</span></dt><dd><dl><dt><span class="sect2">A simple example</span></dt><dt><span class="sect2">Transition table</span></dt><dt><span class="sect2">Defining states with entry/exit actions</span></dt><dt><span class="sect2">Defining a simple state machine</span></dt><dt><span class="sect2">Defining a submachine</span></dt><dt><span class="sect2">Orthogonal regions, terminate state, event deferring</span></dt><dt><span class="sect2">History</span></dt><dt><span class="sect2"><a hre
f="ch03s02.html#d0e1429">Completion (anonymous) transitions</a></span></dt><dt><span class="sect2">Internal transitions</span></dt><dt><span class="sect2">more row types</span></dt><dt><span class="sect2">Explicit entry / entry and exit pseudo-state / fork</span></dt><dt><span class="sect2">Flags</span></dt><dt><span class="sect2">Event Hierarchy</span></dt><dt><span class="sect2">Customizing a state machine / Getting more speed</span></dt><dt><span class="sect2">Choosing the initial event</span></dt><dt><span class="sect2"> Containing state machine (deprecated)</span></dt></dl></dd><dt><span class="sect1">Functor front-end</span></dt><dd><dl><dt><span class="sect2"><a href="ch03s03.html#d0e1953"> Transitio
n table </a></span></dt><dt><span class="sect2">Defining states with entry/exit actions</span></dt><dt><span class="sect2">Defining a simple state machine</span></dt><dt><span class="sect2">Anonymous transitions</span></dt><dt><span class="sect2"><a href="ch03s03.html#d0e2566">Internal
+ transitions</a></span></dt></dl></dd><dt><span class="sect1">eUML (experimental)</span></dt><dd><dl><dt><span class="sect2">Transition table</span></dt><dt><span class="sect2">Defining events, actions and states with entry/exit actions</span></dt><dt><span class="sect2">Defining a simple state machine</span></dt><dt><span class="sect2">Defining a submachine</span></dt><dt><span class="sect2"><a href="ch03s04.html#d0e3117">
+ Attributes / Function call</a></span></dt><dt><span class="sect2">Orthogonal regions, flags, event deferring</span></dt><dt><span class="sect2"><a href="ch03s04.html#d0e3361">
+ Customizing a state machine / Getting
+ more speed</a></span></dt><dt><span class="sect2">Completion / Anonymous transitions</span></dt><dt><span class="sect2">Internal transitions</span></dt><dt><span class="sect2">Other state types</span></dt><dt><span class="sect2">Helper functions</span></dt><dt><span class="sect2">Phoenix-like STL support</span></dt></dl></dd><dt><span class="sect1">Back-end</span></dt><dd><dl><dt><span class="sect2">Creation </span></dt><dt><span class="sect2">Starting a state machine</span></dt><dt><span class="sect2">Event dispatching</span></dt><dt><span class="sect2">Active state(s)</span></dt><dt><span class="sect2"><a href="ch03s05.html#d0e3744">Base state ty
pe </a></span></dt><dt><span class="sect2">Visitor</span></dt><dt><span class="sect2">Flags</span></dt><dt><span class="sect2">Getting a state</span></dt><dt><span class="sect2"> State machine constructor with arguments </span></dt><dt><span class="sect2"><a href="ch03s05.html#d0e3917">Trading run-time speed for
+ better compile-time / multi-TU compilation</a></span></dt></dl></dd></dl></div><div class="sect1" title="Design"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e405"></a>Design</h2></div></div></div><p>MSM is divided between front&#8211;ends and back-ends. At the moment, there is just
+ one back-end. On the front-end side, you will find three of them which are as
+ many state machine description languages, with many more possible. For potential
+ language writers, this document contains a <a class="link" href="ch06s02.html#internals-front-back-interface">description of the interface
+ between front-end and back-end</a>.</p><p>The first front-end is an adaptation of the example provided in the <a class="link" href="http://boostpro.com/mplbook" target="_top">MPL book</a> with actions
+ defined as pointers to state or state machine methods. The second one is based
+ on functors. The third, eUML (embedded UML) is an experimental language based on
+ Boost.Proto and Boost.Typeof and hiding most of the metaprogramming to increase
+ readability. Both eUML and the functor front-end also offer a functional library
+ (a bit like Boost.Phoenix) for use as action language (UML defining
+ none).</p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">State machine glossary&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Basic front-end</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch03s02.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch03s02.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,665 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Basic front-end</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Tutorial"><link rel="prev" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Tutorial"><link rel="next" href="ch03s03.html" title="Functor front-end"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Basic front-end</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Tutorial</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Basic front-end"><div class="titlepage"><div><div><h2 class="title" style="c
lear: both"><a name="d0e418"></a><span class="command"><strong><a name="basic-front-end"></a></strong></span>Basic front-end</h2></div></div></div><p>This is the historical front-end, inherited from the MPL book. It provides a
+ transition table made of rows of different names and functionality. Actions and
+ guards are defined as methods and referenced through a pointer in the
+ transition. This front-end provides a simple interface making easy state
+ machines easy to define, but more complex state machines a bit harder.</p><div class="sect2" title="A simple example"><div class="titlepage"><div><div><h3 class="title"><a name="d0e424"></a>A simple example</h3></div></div></div><p>Let us have a look at a state machine diagram of the founding
+ example:</p><p><span class="inlinemediaobject"><img src="../images/SimpleTutorial.jpg" width="60%"></span></p><p>We are now going to build it with MSM's basic front-end. An <a class="link" href="examples/SimpleTutorial.cpp" target="_top">implementation</a> is also
+ provided.</p></div><div class="sect2" title="Transition table"><div class="titlepage"><div><div><h3 class="title"><a name="d0e438"></a>Transition table</h3></div></div></div><p>As previously stated, MSM is based on the transition table, so let us
+ define one:</p><p>struct transition_table : mpl::vector&lt;</p><p>
+ </p><table frame="void" id="d0e447"><tbody><tr>
+ <td>//</td>
+ <td>Start</td>
+ <td>Event</td>
+ <td>Next</td>
+ <td>Action</td>
+ <td>Guard</td>
+ <td> </td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Stopped ,</td>
+ <td>play,</td>
+ <td>Playing,</td>
+ <td>&amp;player_::start_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Stopped ,</td>
+ <td>open_close,</td>
+ <td>Open,</td>
+ <td>&amp;player_::open_drawer</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>_row &lt;</td>
+ <td>Stopped ,</td>
+ <td>stop,</td>
+ <td>Stopped</td>
+ <td> </td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Open ,</td>
+ <td>open_close ,</td>
+ <td>Empty ,</td>
+ <td>&amp;player_::close_drawer</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Empty ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>&amp;player_::open_drawer</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>row &lt;</td>
+ <td>Empty ,</td>
+ <td>cd_detected ,</td>
+ <td>Stopped ,</td>
+ <td>&amp;player_::store_cd_info ,</td>
+ <td>&amp;player_::good_disk_format</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>row &lt;</td>
+ <td>Empty ,</td>
+ <td>cd_detected ,</td>
+ <td>Playing ,</td>
+ <td>&amp;player_::store_cd_info ,</td>
+ <td>&amp;player_::auto_start</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Playing ,</td>
+ <td>stop ,</td>
+ <td>Stopped ,</td>
+ <td>&amp;player_::stop_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Playing ,</td>
+ <td>pause ,</td>
+ <td>Paused ,</td>
+ <td>&amp;player_::pause_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Playing ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>&amp;player_::stop_and_open</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td> Paused ,</td>
+ <td>end_pause ,</td>
+ <td>Playing ,</td>
+ <td>&amp;player_::resume_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td> Paused ,</td>
+ <td>stop ,</td>
+ <td>Stopped ,</td>
+ <td>&amp;player_::stop_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td> Paused ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>&amp;player_::stop_and_open</td>
+ <td> </td>
+ <td>&gt;</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>&gt; {};</td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p>You will notice that this is almost exactly our founding example. The only
+ change in the transition table is the different types of transitions (rows).
+ The founding example forces one to define an action method and offers no
+ guards. You have 4 basic row types:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">row</code> takes 5 arguments: start state, event, target
+ state, action and guard.</p></li><li class="listitem"><p><code class="code">a_row</code> (&#8220;a&#8221; for action) allows defining only the
+ action and omit the guard condition.</p></li><li class="listitem"><p><code class="code">g_row</code> (&#8220;g&#8221; for guard) allows omitting the action
+ behavior and defining only the guard.</p></li><li class="listitem"><p><code class="code">_row</code> allows omitting action and guard.</p></li></ul></div><p>The signature for an action methods is void method_name (event
+ const&amp;), for example:</p><p><code class="code">void stop_playback(stop const&amp;)</code></p><p>Action methods return nothing and take the argument as const reference. Of
+ course nothing forbids you from using the same action for several
+ events:</p><p><code class="code">template &lt;class Event&gt; void stop_playback(Event
+ const&amp;)</code></p><p>Guards have as only difference the return value, which is a
+ boolean:</p><p><code class="code">bool good_disk_format(cd_detected const&amp; evt)</code></p><p>The transition table is actually a MPL vector (or list), which brings the
+ limitation that the default maximum size of the table is 20. If you need
+ more transitions, overriding this default behavior is necessary, so you need
+ to add before any header:</p><p><code class="code">#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS </code></p><p><code class="code">#define BOOST_MPL_LIMIT_VECTOR_SIZE 30 // or whatever you need
+ </code></p><p><code class="code">#define BOOST_MPL_LIMIT_MAP_SIZE 30 // or whatever you need
+ </code></p><p>The other limitation is that the MPL types are defined only up to 50
+ entries. For the moment, the only solution to achieve more is to add headers
+ to the MPL (luckily, this is not very complicated).</p></div><div class="sect2" title="Defining states with entry/exit actions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e984"></a>Defining states with entry/exit actions</h3></div></div></div><p>While states were enums in the MPL book, they now are classes, which
+ allows them to hold data, provide entry, exit behaviors and be reusable (as
+ they do not know anything about the containing state machine). To define a
+ state, inherit from the desired state type. You will mainly use simple
+ states:</p><p>struct Empty : public msm::front::state&lt;&gt; {};</p><p>They can optionally provide entry and exit behaviors:</p><p><code class="code">struct Empty : public msm::front::state&lt;&gt; {</code></p><p><code class="code">template &lt;class Event, class Fsm&gt; </code></p><p><code class="code">void on_entry(Event const&amp;, Fsm&amp; ) {std::cout &lt;&lt;
+ "entering: Empty" &lt;&lt; std::endl;} </code></p><p><code class="code">template &lt;class Event, class Fsm&gt; </code></p><p><code class="code">void on_exit(Event const&amp;, Fsm&amp; ) {std::cout &lt;&lt;
+ "leaving: Empty" &lt;&lt; std::endl;} </code></p><p><code class="code">};</code></p><p>Notice how the entry and exit behaviors are templatized on the event and
+ state machine. Being generic facilitates reuse. There are more state types
+ (terminate, interrupt, pseudo states, etc.) corresponding to the UML
+ standard state types. These will be described in details in the next
+ sections.</p></div><div class="sect2" title="Defining a simple state machine"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1013"></a>Defining a simple state machine</h3></div></div></div><p>Declaring a state machine is straightforward and is done with a high
+ signal / noise ratio. In our player example, we declare the state machine
+ as:</p><p><code class="code">struct player_ : public msm::front::state_machine_def&lt;player_&gt;{
+ /* see below */}</code></p><p>This declares a state machine using the basic front-end. We now declare
+ inside the state machine structure the initial state:</p><p><code class="code">typedef Empty initial_state;</code></p><p>And that is about all of what is absolutely needed. In the example, the
+ states are declared inside the state machine for readability but this is not
+ a requirements, states can be declared wherever you like.</p><p>All what is left to do is to pick a back-end (which is quite simple as
+ there is only one at the moment):</p><p><code class="code">typedef msm::back::state_machine&lt;player_&gt; player;</code></p><p>You now have a ready-to-use state machine with entry/exit actions, guards,
+ transition actions, a message queue so that processing an event can generate
+ another event. The state machine also adapted itself to your need and
+ removed almost all features we didn't use in this simple example. Note that
+ this is not per default the fastest possible state machine. See the section
+ "getting more speed" to know how to get the maximum speed. In a nutshell,
+ MSM cannot know about your usage of some features so you will have to
+ explicitly tell it.</p><p>State objects are built automatically with the state machine. They will
+ exist until state machine destruction. MSM is using Boost.Fusion behind the
+ hood. This unfortunately means that if you define more than 10 states, you
+ will need to extend the default:</p><p><code class="code">#define FUSION_MAX_VECTOR_SIZE 20 // or whatever you need
+ </code></p><p>When an unexpected event is fired, the <code class="code">no_transition(event, state
+ machine, state id)</code> method of the state machine is called . By
+ default, this method simply asserts when called. It is possible to overwrite
+ the <code class="code">no_transition</code> method to define a different handling:</p><p><code class="code">template &lt;class Fsm,class Event&gt; void no_transition(Event
+ const&amp; e, Fsm&amp; ,int state){...}</code></p><p><span class="underline">Note</span>: you might have noticed that
+ the tutorial calls <code class="code">start()</code> on the state machine just after
+ creation. The start method will initiate the state machine, meaning it will
+ activate the initial state, which means in turn that the initial state's
+ entry behavior will be called. The reason why we need this will be explained
+ in the <a class="link" href="ch03s05.html#backend-start">back-end part</a>. After a call
+ to start, the state machine is ready to process events.</p></div><div class="sect2" title="Defining a submachine"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1061"></a>Defining a submachine</h3></div></div></div><p>We now want to extend our last state machine by making the Playing state a
+ state machine itself (a submachine).</p><p><span class="inlinemediaobject"><img src="../images/CompositeTutorial.jpg" width="60%"></span></p><p>Again, an <a class="link" href="examples/CompositeTutorial.cpp" target="_top">example</a>
+ is also provided.</p><p>A submachine really is a state machine itself, so we declare Playing as
+ such, choosing a front-end and a back-end:</p><p><code class="code">struct Playing_ : public
+ msm::front::state_machine_def&lt;Playing_&gt;{...} </code></p><p><code class="code">typedef msm::back::state_machine&lt;Playing_&gt; Playing;</code></p><p>Like for any state machine, one also needs a transition table and an
+ initial state:</p><p>struct transition_table : mpl::vector&lt;</p><table id="d0e1087"><tbody><tr>
+ <td>//</td>
+ <td>Start</td>
+ <td>Event</td>
+ <td>Next</td>
+ <td>Action</td>
+ <td>Guard</td>
+ <td> </td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>------------------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Song1 ,</td>
+ <td>NextSong,</td>
+ <td>Song2,</td>
+ <td>&amp;Playing_::start_next_song </td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Song2 ,</td>
+ <td>PreviousSong,</td>
+ <td>Song1,</td>
+ <td>&amp;Playing_::start_prev_song </td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Song2 ,</td>
+ <td>NextSong,</td>
+ <td>Song3,</td>
+ <td>&amp;Playing_::start_next_song </td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>a_row &lt;</td>
+ <td>Song3 ,</td>
+ <td>PreviousSong ,</td>
+ <td>Song2 ,</td>
+ <td>&amp;Playing_::start_prev_song </td>
+ <td> </td>
+ <td>&gt;</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>------------------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>&gt; {};</td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p><code class="code">typedef Song1 initial_state; </code></p><p>This is about all you need to do. MSM will now automatically recognize
+ Playing as a submachine and all events handled by Playing (NextSong and
+ PreviousSong) will now be automatically forwarded to Playing whenever this
+ state is active. All other state machine features described later are also
+ available. You can even decide to use a state machine sometimes as
+ submachine or sometimes as an independent state machine.</p></div><div class="sect2" title="Orthogonal regions, terminate state, event deferring"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1278"></a>Orthogonal regions, terminate state, event deferring</h3></div></div></div><p>It is a very common problem in many state machines to have to handle
+ errors. It usually involves defining a transition from all the states to a
+ special error state. Translation: not fun. It is also not practical to find
+ from which state the error originated. The following diagram shows an
+ example of what clearly becomes not very readable:</p><p><span class="inlinemediaobject"><img src="../images/error_no_regions.jpg" width="60%"></span></p><p>This is neither very readable nor beautiful. And we do not even have any
+ action on the transitions yet to make it even less readable.</p><p>Luckily, UML provides a helpful concept, orthogonal regions. See them as
+ lightweight state machines running at the same time inside a common state
+ machine and having the capability to influence one another. The effect is
+ that you have several active states at any time. We can therefore keep our
+ state machine from the previous example and just define a new region made of
+ two states, AllOk and ErrorMode. AllOk is most of the time active. But the
+ error_found error event makes the second region move to the new active state
+ ErrorMode. This event does not interest the main region so it will simply be
+ ignored. "<code class="code">no_transition</code>" will be called only if no region at
+ all handles the event. Also, as UML mandates, every region gets a chance of
+ handling the event, in the order as declared by the
+ <code class="code">initial_state</code> type.</p><p>Adding an orthogonal region is easy, one only needs to declare more states
+ in the <code class="code">initial_state</code> typedef. So, adding a new region with
+ AllOk as the region's initial state is:</p><p><code class="code">typedef mpl::vector&lt;Empty,AllOk&gt; initial_state;</code></p><p><span class="inlinemediaobject"><img src="../images/Orthogonal-deferred.jpg" width="60%"></span></p><p>Furthermore, when you detect an error, you usually do not want events to
+ be further processed. To achieve this, we use another UML feature, terminate
+ states. When any region moves to a terminate state, the state machine
+ &#8220;terminates&#8221; (the state machine and all its states stay alive) and all
+ events are ignored. This is of course not mandatory, one can use orthogonal
+ regions without terminate states. MSM also provides a small extension to
+ UML, interrupt states. If you declare ErrorMode as interrupt state instead
+ of terminate state, the state machine will not handle any event other than
+ the one which ends the interrupt. So it's like a terminate state, with the
+ difference that you are allowed to resume the state machine when a condition
+ (like handling of the original error) is met. </p><p><span class="command"><strong><a name="basic-defer"></a></strong></span>Last but not least, this example also shows
+ here the handling of event deferring. Let's say someone puts a disc and
+ immediately presses play. The event cannot be handled, yet you'd want it to
+ be handled at a later point and not force the user to press play again. The
+ solution is to define it as deferred in the Empty and Open states and get it
+ handled in the first state where the event is not to be deferred. It can
+ then be handled or rejected. In this example, when Stopped becomes active,
+ the event will be handled because only Empty and Open defer the
+ event.</p><p>UML defines event deferring as a state property. To accommodate this, MSM
+ lets you specify this in states by providing a <code class="code">deferred_events</code>
+ type:</p><p><code class="code">struct Empty : public msm::front::state&lt;&gt; </code></p><p><code class="code">{ </code></p><p><code class="code">// if the play event is fired while in this state, defer it until a
+ state </code></p><p><code class="code">// handles or rejects it</code></p><p><code class="code"> typedef mpl::vector&lt;play&gt; deferred_events;</code></p><p><code class="code">...};</code></p><p>Please have a look at the <a class="link" href="examples/Orthogonal-deferred.cpp" target="_top">complete
+ example</a>.</p><p>While this is wanted by UML and is simple, it is not always practical
+ because one could wish to defer only in certain conditions. One could also
+ want to make this be part of a transition action with the added bonus of a
+ guard for more sophisticated behaviors. It would also be conform to the MSM
+ philosophy to get as much as possible in the transition table, where you
+ have the whole state machine structure. This is also possible but not
+ practical with this front-end so we will need to pick a different row from
+ the functor front-end. For a complete description of the <code class="code">Row</code>
+ type, please have a look at the <span class="command"><strong><a class="command" href="ch03s03.html#functor-front-end">functor front-end.</a></strong></span></p><p>First, as there is no state where MSM can automatically find out the usage
+ of this feature, we need to require deferred events capability explicitly,
+ by adding a type in the state machine definition:</p><p><code class="code">struct player_ : public
+ msm::front::state_machine_def&lt;player_&gt;</code></p><p><code class="code">{ </code></p><p><code class="code">typedef int activate_deferred_events;</code></p><p><code class="code">...};</code></p><p>We can now defer an event in any transition of the transition table by
+ using as action the predefined <code class="code">msm::front::Defer</code> functor, for
+ example:</p><p><code class="code">Row &lt; Empty , play , none , Defer , none &gt;</code></p><p>This is an internal transition row(see <span class="command"><strong><a class="command" href="ch03s02.html#internal-transitions">internal transitions</a></strong></span>) but
+ you can ignore this for the moment. It just means that we are not leaving
+ the Empty state. What matters is that we use Defer as action. This is
+ roughly equivalent to the previous syntax but has the advantage of giving
+ you all the information in the transition table with the added power of
+ transition behavior.</p><p>The second difference is that as we now have a transition defined, this
+ transition can play in the resolution of <span class="command"><strong><a class="command" href="ch02s02.html#transition-conflict">transition conflicts</a></strong></span>. For
+ example, we could model an "if (condition2) move to Playing else if
+ (condition1) defer play event":</p><p>
+ <code class="code">Row &lt; Empty , play , none , Defer , condition1 &gt;,</code></p><p><code class="code">g_row &lt; Empty , play , Playing , &amp;player_::condition2
+ &gt;</code></p><p>Please have a look at <a class="link" href="examples/Orthogonal-deferred2.cpp" target="_top">this possible implementation</a>.</p></div><div class="sect2" title="History"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1393"></a>History</h3></div></div></div><p>UML defines two types of history, Shallow History and Deep History. In the
+ previous examples, if the player was playing the second song and the user
+ pressed pause, leaving Playing, at the next press on the play button, the
+ Playing state would become active and the first song would play again. Soon
+ would the first client complaints follow. They'd of course demand, that if
+ the player was paused, then it should remember which song was playing. But
+ it the player was stopped, then it should restart from the first song. How
+ can it be done? Of course, you could add a bit of programming logic and
+ generate extra events to make the second song start if coming from Pause.
+ Something like: </p><p><code class="code">if (Event == end_pause) { for (int i=0;i&lt; song number;++i) {
+ player.process_event(NextSong()); } } </code></p><p>Not much to like in this example, isn't it? To solve this problem, you
+ define what is called a shallow or a deep history. A shallow history
+ reactivates the last active substate of a submachine when this submachine
+ becomes active again. The deep history does the same recursively, so if this
+ last active substate of the submachine was itself a submachine, its last
+ active substate would become active and this will continue recursively until
+ an active state is a normal state. For example, let us have a look at the
+ following UML diagram: </p><p><span class="inlinemediaobject"><img src="../images/HistoryTutorial.jpg" width="60%"></span></p><p>Notice that the main difference compared to previous diagrams is that the
+ initial state is gone and replaced by a History symbol (the H inside a
+ circle).</p><p>As explained in the <span class="command"><strong><a class="command" href="ch02s02.html#uml-history">small UML
+ tutorial</a></strong></span>, History is a good concept with a not completely
+ satisfying specification. MSM kept the concept but not the specification and
+ goes another way by making this a policy and you can add your own history
+ types (the <a class="link" href="re02.html#history-interface">reference</a> explains
+ what needs to be done). Furthermore, History is a backend policy. This
+ allows you to reuse the same state machine definition with different history
+ policies in different contexts.</p><p>Concretely, your frontend stays unchanged:</p><p><code class="code">struct Playing_ : public
+ msm::front::state_machine_def&lt;Playing_&gt;</code></p><p>You then add the policy to the backend as second parameter:</p><p><code class="code">typedef
+ msm::back::state_machine&lt;Playing_,msm::back::ShallowHistory&lt;mpl::vector&lt;end_pause&gt;
+ &gt; &gt; Playing;</code></p><p>This states that a shallow history must be activated if the Playing state
+ machine gets activated by the end_pause event and only this one (or any
+ other event added to the mpl::vector). If the state machine was in the
+ Stopped state and the event play was generated, the history would not be
+ activated and the normal initial state would become active. By default,
+ history is disabled. For your convenience the library provides in addition
+ to ShallowHistory a non-UML standard AlwaysHistory policy (likely to be your
+ main choice) which always activates history, whatever event triggers the
+ submachine activation. Deep history is not available as a policy (but could
+ be added). The reason is that it would conflict with policies which
+ submachines could define. Of course, if for example, Song1 were a state
+ machine itself, it could use the ShallowHistory policy itself thus creating
+ Deep History for itself. </p></div><div class="sect2" title="Completion (anonymous) transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1429"></a>Completion (anonymous) transitions</h3></div></div></div><p><span class="command"><strong><a name="anonymous-transitions"></a></strong></span>The following diagram shows an
+ example making use of this feature:</p><p><span class="inlinemediaobject"><img src="../images/Anonymous.jpg" width="60%"></span></p><p>Anonymous transitions are transitions without a named event. This means
+ that the transition automatically fires when the predecessor state is
+ entered (to be exact, after the entry action). Otherwise it is a normal
+ transition with actions and guards. Why would you need something like that?
+ A possible case would be if a part of your state machine implements some
+ algorithm, where states are steps of the algorithm implementation. Then,
+ using several anonymous transitions with different guard conditions, you are
+ actually implementing some if/else statement. Another possible use would be
+ a real-time system called at regular intervals and always doing the same
+ thing, meaning implementing the same algorithm. The advantage is that once
+ you know how long a transition takes to execute on the system, by
+ calculating the longest path (the number of transitions from start to end),
+ you can pretty much know how long your algorithm will take in the worst
+ case, which in turns tells you how much of a time frame you are to request
+ from a scheduler. </p><p>If you are using Executable UML (a good book describing it is "Executable
+ UML, a foundation for Model-Driven Architecture"), you will notice that it
+ is common for a state machine to generate an event to itself only to force
+ leaving a state. Anonymous transitions free you from this constraint.</p><p>If you do not use this feature in a concrete state machine, MSM will
+ deactivate it and you will not pay for it. If you use it, there is however a
+ small performance penalty as MSM will try to fire a compound event (the
+ other UML name for anonymous transitions) after every taken transition. This
+ will therefore double the event processing cost, which is not as bad as it
+ sounds as MSM&#8217;s execution speed is very high anyway.</p><p>To define such a transition, use &#8220;none&#8221; as event in the transition table,
+ for example:</p><p><code class="code">row &lt; State3 , none , State4 , &amp;p::State3ToState4 ,
+ &amp;p::always_true &gt;</code></p><p><a class="link" href="examples/AnonymousTutorial.cpp" target="_top">An implementation</a>
+ of the state machine diagram is also provided.</p></div><div class="sect2" title="Internal transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1454"></a><span class="command"><strong><a name="internal-transitions"></a></strong></span>Internal transitions</h3></div></div></div><p>Internal transitions are transitions executing in the scope of the active
+ state, a simple state or a submachine. One can see them as a self-transition
+ of this state, without an entry or exit action called. This is useful when
+ all you want is to execute some code for a given event in a given
+ state.</p><p>Internal transitions are specified as having a higher priority than normal
+ transitions. While it makes sense for a submachine with exit points, it is
+ surprising for a simple state. MSM lets you define the transition priority
+ by setting the transition&#8217;s position inside the transition table (see
+ <span class="command"><strong><a class="command" href="ch06.html#run-to-completion">internals</a></strong></span> ). The
+ difference between "normal" and internal transitions is that internal
+ transitions have no target state, therefore we need new row types. We had
+ a_row, g_row, _row and row, we now add a_irow, g_irow, _irow and irow which
+ are like normal transitions but define no target state. For, example an
+ internal transition with a guard condition could be:</p><p><code class="code">g_irow &lt; Empty /*state*/ , cd_detected
+ /*event*/,&amp;p::internal_guard /* guard */ &gt;</code></p><p>These new row types can be placed anywhere in the transition table so that
+ you can still have your state machine structure grouped together. The only
+ difference of behavior with the UML standard is the missing notion of higher
+ priority for internal transitions. Please have a look at <a class="link" href="examples/SimpleTutorialInternal.cpp" target="_top">the
+ example</a>.</p><p>It is also possible to do it the UML-conform way by declaring a transition
+ table called <code class="code">internal transition_table</code> inside the state itself
+ and using internal row types. For example:</p><p><code class="code">struct Empty : public msm::front::state&lt;&gt; {</code></p><p><code class="code">struct internal_transition_table : mpl::vector&lt;</code></p><p><code class="code">a_internal &lt; cd_detected , Empty, &amp;Empty::internal_action
+ &gt;</code></p><p><code class="code">&gt; {};</code></p><p><code class="code">};</code></p><p>This declares an internal transition table called
+ internal_transition_table and reacting on the event cd_detected by calling
+ internal_action on Empty. Let us note a few points:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>internal tables are NOT called transition_table but
+ internal_transition_table</p></li><li class="listitem"><p>they use different but similar row types: a_internal,
+ g_internal, _internal and internal.</p></li><li class="listitem"><p>These types take as first template argument the triggering
+ event and then the action and guard method. Note that the only
+ real difference to classical rows is the extra argument before
+ the function pointer. This is the type on which the function
+ will be called.</p></li><li class="listitem"><p>This also allows you, if you wish, to use actions and guards
+ from another state of the state machine or in the state machine
+ itself.</p></li><li class="listitem"><p>submachines can have an internal transition table and a
+ classical transition table.</p></li></ul></div><p>The <a class="link" href="examples/TestInternal.cpp" target="_top">following example</a>
+ makes use of an a_internal. It also uses functor-based internal transitions
+ which will be explained in <span class="command"><strong><a class="command" href="ch03s03.html#functor-internal-transitions">the functor
+ front-end</a></strong></span>, please ignore them for the moment. Also note that
+ the state-defined internal transitions, having the highest priority (as
+ mandated by the UML standard), are tried before those defined inside the
+ state machine transition table.</p><p>Which method should you use? It depends on what you need:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>the first version (using irow) is simpler and likely to
+ compile faster. It also lets you choose the priority of your
+ internal transition.</p></li><li class="listitem"><p>the second version is more logical from a UML perspective and
+ lets you make states more useful and reusable. It also allows
+ you to call actions and guards on any state of the state
+ machine.</p></li></ul></div><p>
+ <span class="command"><strong><a name="internal-transitions-note"></a></strong></span><span class="underline"><span class="bold"><strong>Note</strong></span></span>: There is an added
+ possibility coming from this feature. The
+ <code class="code">internal_transition_table</code> transitions being added directly
+ inside the main state machine's transition table, it is possible, if it is
+ more to your state, to distribute your state machine definition a bit like
+ Boost.Statechart, leaving to the state machine itself the only task of
+ declaring the states it wants to use using the
+ <code class="code">explicit_creation</code> type definition. While this is not the
+ author's favorite way, it is still possible. A simplified example using only
+ two states will show this possibility:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><a class="link" href="examples/distributed_table/DistributedTable.cpp" target="_top">state machine definition</a></p></li><li class="listitem"><p>Empty <a class="link" href="examples/distributed_table/Empty.hpp" target="_top">header</a> and <a class="link" href="examples/distributed_table/Empty.cpp" target="_top">cpp</a></p></li><li class="listitem"><p>Open <a class="link" href="examples/distributed_table/Open.hpp" target="_top">header</a> and <a class="link" href="examples/distributed_table/Open.cpp" target="_top">cpp</a></p></li><li class="listitem"><p><a class="link" href="examples/distributed_table/Events.hpp" target="_top">events definition</a></p></li></ul></div><p>There is an added bonus offered for submachines, which can have both the
+ standard transition_table and an internal_transition_table (which has a
+ higher priority). This makes it easier if you decide to make a full
+ submachine from a state. It is also slightly faster than the standard
+ alternative, adding orthogonal regions, because event dispatching will, if
+ accepted by the internal table, not continue to the subregions. This gives
+ you a O(1) dispatch instead of O(number of regions). While the example is
+ with eUML, the same is also possible with any front-end.</p></div><div class="sect2" title="more row types"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1567"></a>more row types</h3></div></div></div><p>It is also possible to write transitions using actions and guards not just
+ from the state machine but also from its contained states. In this case, one
+ must specify not just a method pointer but also the object on which to call
+ it. This transition row is called, not very originally, <code class="code">row2</code>.
+ They come, like normal transitions in four flavors: <code class="code">a_row2, g_row2,
+ _row2 and row2</code>. For example, a transition calling an action from
+ the state Empty could be:</p><p><code class="code">a_row2 &lt; Stopped , open_close , Open , Empty /*action source*/ ,
+ &amp;Empty::open_drawer /*action*/&gt;</code></p><p>The same capabilities are also available for internal transitions so that
+ we have: <code class="code">a_irow2, g_irow2, _irow2 and row2</code>. For transitions
+ defined as part of the <code class="code">internal_transition_table</code>, you can use
+ the <span class="command"><strong><a class="command" href="ch03s02.html#internal-transitions">a_internal, g_internal,
+ _internal, internal</a></strong></span> row types from the previous
+ sections.</p><p>These row types allow us to distribute the state machine code among
+ states, making them reusable and more useful. Using transition tables inside
+ states also contributes to this possibility. An <a class="link" href="examples/SimpleTutorial2.cpp" target="_top">example</a> of these new
+ rows is also provided.</p></div><div class="sect2" title="Explicit entry / entry and exit pseudo-state / fork"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1597"></a>Explicit entry / entry and exit pseudo-state / fork</h3></div></div></div><p>MSM (almost) fully supports these features, described in the <span class="command"><strong><a class="command" href="ch02s02.html#uml-history">small UML tutorial</a></strong></span>. Almost because
+ there are currently two limitations: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>it is only possible to explicitly enter a sub- state of the
+ target but not a sub-sub state.</p></li><li class="listitem"><p>it is not possible to explicitly exit. Exit points must be
+ used.</p></li></ul></div><p>Let us see a concrete example:</p><p><span class="inlinemediaobject"><img src="../images/entry%20tutorial.jpg" width="60%"></span></p><p>We find in this diagram:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>A &#8220;normal&#8221; activation of SubFsm2, triggered by event1. In each
+ region, the initial state is activated, i.e. SubState1 and
+ SubState1b.</p></li><li class="listitem"><p>An explicit entry into SubFsm2::SubState2 for region &#8220;1&#8221; with
+ event2 as trigger, meaning that in region &#8220;2&#8221; the initial state,
+ SubState1b, activated.</p></li><li class="listitem"><p>A fork into regions &#8220;1&#8221; and &#8220;2&#8221; to the explicit entries
+ SubState2 and SubState2b, triggered by event3. Both states
+ become active so no region is default activated (if we had a
+ third one, it would be).</p></li><li class="listitem"><p>A connection of two transitions through an entry pseudo state,
+ SubFsm2::PseudoEntry1, triggered by event4 and triggering also
+ the second transition on the same event (both transitions must
+ be triggered by the same event). Region &#8220;2&#8221; is default-activated
+ and SubState1b becomes active.</p></li><li class="listitem"><p>An exit from SubFsm2 using an exit pseudo-state, PseudoExit1,
+ triggered by event5 and connecting two transitions using the
+ same event. Again, the event is forwarded to the second
+ transition and both regions are exited, as SubFsm2 becomes
+ inactive. Note that if no transition is defined from
+ PseudoExit1, an error (as defined in the UML standard) will be
+ detected and no_transition called.</p></li></ul></div><p>The example is also <a class="link" href="examples/DirectEntryTutorial.cpp" target="_top">fully implemented</a>.</p><p>This sounds complicated but the syntax is simple.</p><div class="sect3" title="Explicit entry"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1643"></a>Explicit entry</h4></div></div></div><p>First, to define that a state is an explicit entry, you have to make
+ it a state and mark it as explicit, giving as template parameters the
+ region id (the region id starts with 0 and corresponds to the first
+ initial state of the initial_state type sequence).</p><p><code class="code">struct SubState2 : public msm::front::state&lt;&gt; , public
+ msm::front::explicit_entry&lt;0&gt;</code></p><p>And define the submachine as:</p><p><code class="code">typedef msm::back::state_machine&lt;SubFsm2_&gt;
+ SubFsm2;</code></p><p>You can then use it as target in a transition with State1 as
+ source:</p><p><code class="code">_row &lt; State1, Event2, SubFsm2::direct&lt;
+ SubFsm2_::SubState2&gt; &gt;</code></p><p>The syntax deserves some explanation. SubFsm2_ is a front end.
+ SubState2 is a nested state, therefore the SubFsm2_::SubState2 syntax.
+ The containing machine (containing State1 and SubFsm2) refers to the
+ backend instance (SubFsm2). SubFsm2::direct states that an explicit
+ entry is desired.</p><p><span class="underline">Note (also valid for forks)</span>: in
+ order to make compile time more bearable for the more standard cases,
+ and unlike initial states, explicit entry states which are also not
+ found in the transition table of the entered submachine (a rare case) do
+ NOT get automatically created. To explicitly create such states, you
+ need to add in the state machine containing the explicit states a simple
+ typedef giving a sequence of states to be explicitly created
+ like:</p><p><code class="code">typedef mpl::vector&lt;SubState2,SubState2b&gt;
+ explicit_creation;</code></p></div><div class="sect3" title="Fork"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1670"></a>Fork</h4></div></div></div><p>Need a fork instead of an explicit entry? As a fork is an explicit
+ entry into states of different regions, we do not change the state
+ definition compared to the explicit entry and specify as target a list
+ of explicit entry states:</p><p><code class="code">_row &lt; State1, Event3, mpl::vector&lt;SubFsm2::direct&lt;
+ SubFsm2_::SubState2&gt;, SubFsm2::direct &lt;SubFsm2_::SubState2b&gt;
+ &gt;</code></p><p>With SubState2 defined as before and SubState2b defined as being in
+ the second region (Caution: MSM does not check that the region is
+ correct):</p><p><code class="code">struct SubState2b : public msm::front::state&lt;&gt; , public
+ msm::front::explicit_entry&lt;1&gt;</code></p></div><div class="sect3" title="Entry pseudo states"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1683"></a>Entry pseudo states</h4></div></div></div><p> To define an entry pseudo state, you need derive from the
+ corresponding class and give the region id:</p><p><code class="code">struct PseudoEntry1 : public
+ msm::front::entry_pseudo_state&lt;0&gt;</code></p><p>And add the corresponding transition in the top-level state machine's
+ transition table:</p><p><code class="code">_row &lt; State1, Event4,
+ SubFsm2::entry_pt&lt;SubFsm2_::PseudoEntry1&gt; &gt;</code></p><p>And another in the SubFsm2_ submachine definition (remember that UML
+ defines an entry point as a connection between two transitions), for
+ example this time with an action method:</p><p><code class="code">_row &lt; PseudoEntry1, Event4, SubState3,
+ &amp;SubFsm2_::entry_action &gt;</code></p></div><div class="sect3" title="Exit pseudo states"><div class="titlepage"><div><div><h4 class="title"><a name="d0e1701"></a> Exit pseudo states </h4></div></div></div><p>And finally, exit pseudo states are to be used almost the same way,
+ but defined differently: it takes as template argument the event to be
+ forwarded (no region id is necessary):</p><p><code class="code">struct PseudoExit1 : public
+ exit_pseudo_state&lt;event6&gt;</code></p><p>And you need, like for entry pseudo states, two transitions, one in
+ the submachine:</p><p><code class="code">_row &lt; SubState3, Event5, PseudoExit1 &gt;</code></p><p>And one in the containing state machine:</p><p><code class="code">_row &lt; SubFsm2::exit_pt&lt;SubFsm2_::PseudoExit1&gt;, Event6,
+ State2 &gt;</code></p><p><span class="underline">Important note 1:</span> UML defines
+ transiting to an entry pseudo state and having either no second
+ transition or one with a guard as an error but defines no error
+ handling. MSM will tolerate this behavior; the entry pseudo state will
+ simply be the newly active state.</p><p><span class="underline">Important note 2</span>: UML defines
+ transiting to an exit pseudo state and having no second transition as an
+ error, and also defines no error handling. Therefore, it was decided to
+ implement exit pseudo state as terminate states and the containing
+ composite not properly exited will stay terminated as it was technically
+ &#8220;exited&#8221;.</p><p><span class="underline">Important note 3:</span> UML states
+ that for the exit point, the same event must be used in both
+ transitions. MSM relaxes this rule and only wants the event on the
+ inside transition to be convertible to the one of the outside
+ transition. In our case, event6 is convertible from event5. Notice that
+ the forwarded event must be named in the exit point definition. For
+ example, we could define event6 as simply as:</p><p><code class="code">struct event6 { event6(){} template &lt;class Event&gt;
+ event6(Event const&amp;){} };//convertible from any event</code>
+ </p></div></div><div class="sect2" title="Flags"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1735"></a>Flags</h3></div></div></div><p>This <a class="link" href="examples/Flags.cpp" target="_top">tutorial</a> is devoted to a
+ concept not defined in UML: flags. It has been added into MSM after proving
+ itself useful on many occasions. Please, do not be frightened as we are not
+ talking about ugly shortcuts made of an improbable collusion of
+ Booleans.</p><p>If you look into the Boost.Statechart documentation you'll find this
+ code:</p><p><code class="code">if ( ( state_downcast&lt; const NumLockOff * &gt;() != 0 ) &amp;&amp;
+ </code></p><p><code class="code">( state_downcast&lt; const CapsLockOff * &gt;() != 0 ) &amp;&amp;
+ </code></p><p><code class="code">( state_downcast&lt; const ScrollLockOff * &gt;() != 0 ) )
+ </code></p><p>While correct and found in many UML books, this can be error-prone and a
+ potential time-bomb when your state machine grows and you add new states or
+ orthogonal regions.</p><p>And most of all, it hides the real question, which would be &#8220;does my state
+ machine's current state define a special property&#8221;? In this special case
+ &#8220;are my keys in a lock state&#8221;? So let's apply the Fundamental Theorem of
+ Software Engineering and move one level of abstraction higher.</p><p>In our player example, let's say we need to know if the player has a
+ loaded CD. We could do the same:</p><p><code class="code">if ( ( state_downcast&lt; const Stopped * &gt;() != 0 ) &amp;&amp;
+ </code></p><p><code class="code">( state_downcast&lt; const Open * &gt;() != 0 ) &amp;&amp;
+ </code></p><p><code class="code">( state_downcast&lt; const Paused * &gt;() != 0 )
+ &amp;&amp;</code></p><p><code class="code">( state_downcast&lt; const Playing * &gt;() != 0 )</code></p><p><code class="code"> ) </code></p><p>Or flag these 4 states as CDLoaded-able. You add a flag_list type into
+ each flagged state:</p><p><code class="code">typedef mpl::vector1&lt;CDLoaded&gt; flag_list;</code></p><p>You can even define a list of flags, for example in Playing:</p><p><code class="code">typedef mpl::vector2&lt;PlayingPaused,CDLoaded&gt;
+ flag_list;</code></p><p>This means that Playing supports both properties. To check if your player
+ has a loaded CD, check if your flag is active in the current state:</p><p><code class="code">player p; if (p.is_flag_active&lt;CDLoaded&gt;()) ... </code></p><p>And what if you have orthogonal regions? How to decide if a state machine
+ is in a flagged state? By default, you keep the same code and the current
+ states will be OR'ed, meaning if one of the active states has the flag, then
+ is_flag_active returns true. Of course, in some cases, you might want that
+ all of the active states are flagged for the state to be active. You can
+ also AND the active states:</p><p><code class="code">if (p.is_flag_active&lt;CDLoaded,player::Flag_AND&gt;())
+ ...</code></p><p>The following diagram displays the flag situation in the tutorial.</p><p><span class="inlinemediaobject"><img src="../images/FlagsTutorial.jpg" width="60%"></span></p></div><div class="sect2" title="Event Hierarchy"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1801"></a><span class="command"><strong><a name="event-hierarchy"></a></strong></span>Event Hierarchy</h3></div></div></div><p>There are cases where one needs transitions based on categories of events.
+ An example is text parsing. Let's say you want to parse a string and use a
+ state machine to manage your parsing state. You want to parse 4 digits and
+ decide to use a state for every matched digit. Your state machine could look
+ like:</p><p><span class="inlinemediaobject"><img src="../images/ParsingDigits.jpg" width="30%"></span></p><p>But how to detect the digit event? We would like to avoid defining 10
+ transitions on char_0, char_1... between two states as it would force us to
+ write 4 x 10 transitions and the compile-time would suffer. To solve this
+ problem, MSM supports the triggering of a transition on a subclass event.
+ For example, if we define digits as: </p><p><code class="code">struct digit {};</code></p><p><code class="code">struct char_0 : public digit {}; </code></p><p>And to the same for other digits, we can now fire char_0, char_1 events
+ and this will cause a transition with "digit" as trigger to be taken.</p><p>An <a class="link" href="examples/ParsingDigits.cpp" target="_top">example</a> with
+ performance measurement, taken from the documentation of Boost.Xpressive
+ illustrates this example. You might notice that the performance is actually
+ very good (in this case even better).</p></div><div class="sect2" title="Customizing a state machine / Getting more speed"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1826"></a>Customizing a state machine / Getting more speed</h3></div></div></div><p>MSM is offering many UML features at a high-speed, but sometimes, you just
+ need more speed and are ready to give up some features in exchange. A
+ process_event is handling several tasks: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>checking for terminate/interrupt states</p></li><li class="listitem"><p>handling the message queue (for entry/exit/transition actions
+ generating themselves events)</p></li><li class="listitem"><p>handling deferred events</p></li><li class="listitem"><p>catching exceptions (or not)</p></li><li class="listitem"><p>handling the state switching and action calls</p></li></ul></div><p>Of these tasks, only the last one is absolutely necessary to
+ a state machine (its core job), the other ones are nice-to-haves which cost
+ CPU time. In many cases, it is not so important, but in embedded systems,
+ this can lead to ad-hoc state machine implementations. MSM detects by itself
+ if a concrete state machine makes use of terminate/interrupt states and
+ deferred events and deactivates them if not used. For the other two, if you
+ do not need them, you need to help by indicating it in your implementation.
+ This is done with two simple typedefs:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">no_exception_thrown</code> indicates that behaviors will
+ never throw and MSM does not need to catch anything</p></li><li class="listitem"><p><code class="code">no_message_queue</code> indicates that no action will
+ itself generate a new event and MSM can save us the message
+ queue.</p></li></ul></div><p>The third configuration possibility, explained <a class="link" href="ch03s02.html#basic-defer">here</a>, is to manually activate deferred
+ events, using <code class="code">activate_deferred_events</code>. For example, the
+ following state machine sets all three configuration types:</p><p><code class="code">struct player_ : public msm::front::state_machine_def&lt;player_&gt;
+ {</code></p><p><code class="code">// no need for exception handling or message queue</code></p><p><code class="code">typedef int no_exception_thrown;</code></p><p><code class="code">typedef int no_message_queue;</code></p><p><code class="code">// also manually enable deferred events</code></p><p><code class="code">typedef int activate_deferred_events</code></p><p><code class="code">...// rest of implementation</code></p><p><code class="code">};</code></p></div><div class="sect2" title="Choosing the initial event"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1890"></a>Choosing the initial event</h3></div></div></div><p>A state machine is started using the <code class="code">start</code> method. This
+ causes the initial state's entry behavior to be executed. Like every entry
+ behavior, it becomes as parameter the event causing the state to be entered.
+ But when the machine starts, there was no event triggered. In this case, MSM
+ sends <code class="code">msm::back::state_machine&lt;...&gt;::InitEvent</code>, which might
+ not be the default you'd want. For this special case, MSM provides a
+ configuration mechanism in the form of a typedef. If the state machine's
+ front-end definition provides an initial_event typedef set to another event,
+ this event will be used. For example:</p><p><code class="code">struct my_initial_event{};</code></p><p><code class="code">struct player_ : public
+ msm::front::state_machine_def&lt;player_&gt;{</code></p><p><code class="code">...</code></p><p><code class="code">typedef my_initial_event initial_event; };</code></p></div><div class="sect2" title="Containing state machine (deprecated)"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1913"></a> Containing state machine (deprecated)</h3></div></div></div><p>This feature is still supported in MSM for backward compatibility but made
+ obsolete by the fact that every guard/action/entry action/exit action get
+ the state machine passed as argument and might be removed at a later
+ time.</p><p>All of the states defined in the state machine are created upon state
+ machine construction. This has the huge advantage of a reduced syntactic
+ noise. The cost is a small loss of control for the user on the state
+ creation and access. But sometimes you needed a way for a state to get
+ access to its containing state machine. Basically, a state needs to change
+ its declaration to:</p><p><code class="code">struct Stopped : public msm::front::state&lt;sm_ptr&gt;</code></p><p>And to provide a set_sm_ptr function: <code class="code">void set_sm_ptr(player*
+ pl)</code></p><p>to get a pointer to the containing state machine. The same applies to
+ terminate_state / interrupt_state and entry_pseudo_state /
+ exit_pseudo_state. </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;3.&nbsp;Tutorial&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Functor front-end</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch03s03.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch03s03.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,258 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Functor front-end</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Tutorial"><link rel="prev" href="ch03s02.html" title="Basic front-end"><link rel="next" href="ch03s04.html" title="eUML (experimental)"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Functor front-end</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Tutorial</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Functor front-end"><div class="titlepage"><div><div><h2 class="title" style="c
lear: both"><a name="d0e1929"></a><span class="command"><strong><a name="functor-front-end"></a></strong></span>Functor front-end</h2></div></div></div><p>The functor front-end is the preferred front-end at the moment. It is more
+ powerful than the standard front-end and has a more readable transition table.
+ It also makes it easier to reuse parts of state machines. Like <span class="command"><strong><a class="command" href="ch03s04.html#eUML-front-end">eUML</a></strong></span>, it also comes with a good deal
+ of predefined actions. Actually, eUML generates a functor front-end through
+ Boost.Typeof and Boost.Proto so both offer the same functionality.</p><p>The rows which MSM offered in the previous front-end come in different
+ flavors. We saw the a_row, g_row, _row, row, not counting internal rows. This is
+ already much to know, so why define new rows? These types have some
+ disadvantages: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>They are more typing and information than we would wish. This
+ means syntactic noise and more to learn.</p></li><li class="listitem"><p>Function pointers are weird in C++.</p></li><li class="listitem"><p>The action/guard signature is limited and does not allow for more
+ variations of parameters (source state, target state, current state
+ machine, etc.)</p></li><li class="listitem"><p>It is not easy to reuse action code from a state machine to
+ another.</p></li></ul></div><div class="sect2" title="Transition table"><div class="titlepage"><div><div><h3 class="title"><a name="d0e1953"></a> Transition table </h3></div></div></div><p>We can change the definition of the simple tutorial's transition table
+ to:</p><p>
+ </p><table id="d0e1960"><tbody><tr>
+ <td>//</td>
+ <td>Start</td>
+ <td>Event</td>
+ <td>Next</td>
+ <td>Action</td>
+ <td>Guard</td>
+ <td> </td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Stopped ,</td>
+ <td>play,</td>
+ <td>Playing,</td>
+ <td>start_playback</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Stopped ,</td>
+ <td>open_close,</td>
+ <td>Open,</td>
+ <td>open_drawer,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Stopped ,</td>
+ <td>stop,</td>
+ <td>Stopped,</td>
+ <td> </td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Open ,</td>
+ <td>open_close ,</td>
+ <td>Empty ,</td>
+ <td>close_drawer,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Empty ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>open_drawer</td>
+ <td> </td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Empty ,</td>
+ <td>cd_detected ,</td>
+ <td>Stopped ,</td>
+ <td>store_cd_info ,</td>
+ <td>good_disk_format</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>g_row &lt;</td>
+ <td>Empty ,</td>
+ <td>cd_detected ,</td>
+ <td>Playing ,</td>
+ <td>store_cd_info ,</td>
+ <td>&amp;player_::auto_start</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Playing ,</td>
+ <td>stop ,</td>
+ <td>Stopped ,</td>
+ <td>stop_playback,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Playing ,</td>
+ <td>pause ,</td>
+ <td>Paused ,</td>
+ <td>pause_playback,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td>Playing ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>stop_and_open,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td> Paused ,</td>
+ <td>end_pause ,</td>
+ <td>Playing ,</td>
+ <td>resume_playback,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td> Paused ,</td>
+ <td>stop ,</td>
+ <td>Stopped ,</td>
+ <td>stop_playback,</td>
+ <td> none</td>
+ <td>&gt;,</td>
+ </tr><tr>
+ <td>Row &lt;</td>
+ <td> Paused ,</td>
+ <td>open_close ,</td>
+ <td>Open ,</td>
+ <td>stop_and_open,</td>
+ <td> none</td>
+ <td>&gt;</td>
+ </tr><tr>
+ <td>//</td>
+ <td>+---------+</td>
+ <td>-------------+</td>
+ <td>---------+</td>
+ <td>---------------------+</td>
+ <td>----------------------+</td>
+ <td> </td>
+ </tr><tr>
+ <td>&gt; {};</td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p>Transitions are now of type "Row" with exactly 5 template arguments:
+ source state, event, target state, action and guard. Wherever there is
+ nothing (for example actions and guards), write "none". Actions and guards
+ are no more methods but functors getting as arguments the detected event,
+ the state machine, source and target state:</p><p><code class="code">struct store_cd_info { </code></p><p><code class="code">template &lt;class Fsm,class Evt,class SourceState,class
+ TargetState&gt; </code></p><p><code class="code">void operator()(Evt const&amp;, Fsm&amp; fsm, SourceState&amp;,
+ TargetState&amp; ) </code></p><p><code class="code"> {</code></p><p><code class="code"> cout &lt;&lt; "player::store_cd_info" &lt;&lt; endl;
+ fsm.process_event(play()); </code></p><p><code class="code"> } </code></p><p><code class="code">}; </code></p><p>The advantage of functors compared to functions are that functors are
+ generic and reusable. They also allow passing more parameters than just
+ events. The guard functors are the same but have an operator() returning a
+ bool.</p><p>It is also possible to mix rows from different front-ends. To show this, a
+ g_row has been left in the transition table. <span class="underline">Note:</span> in case the action functor is used in the transition
+ table of a state machine contained inside a top-level state machine, the
+ &#8220;fsm&#8221; parameter refers to the lowest-level state machine (referencing this
+ action), not the top-level one.</p><p>To illustrate the reusable point, MSM comes with a whole set of predefined
+ functors. Please refer to eUML for the <a class="link" href="pt02.html#Reference-begin">full list</a>. For example, we are now going to replace the first
+ action by an action sequence and the guard by a more complex functor.</p><p>We decide we now want to execute two actions in the first transition
+ (Stopped -&gt; Playing). We only need to change the action start_playback to
+ <code class="code">ActionSequence_&lt; mpl::vector&lt;some_action, start_playback&gt; &gt;
+ </code> and now will execute some_action and start_playback every time the
+ transition is taken. ActionSequence_ is a functor calling each action of the
+ mpl::vector in sequence.</p><p>We also want to replace good_disk_format by a condition of the type:
+ &#8220;good_disk_format &amp;&amp; (some_condition || some_other_condition)&#8221;. We
+ can achieve this using And_ and Or_ functors:
+ <code class="code">And_&lt;good_disk_format,Or_&lt; some_condition ,
+ some_other_condition&gt; &gt;</code>. It even starts looking like functional
+ programming. MSM ships with functors for operators, state machine usage, STL
+ algorithms or container methods.</p></div><div class="sect2" title="Defining states with entry/exit actions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e2491"></a>Defining states with entry/exit actions</h3></div></div></div><p>You probably noticed that we just showed a different transition table and
+ that we even mixed rows from different front-ends. This means that you can
+ do this and leave the definitions for states unchanged. Most examples are
+ doing this as it is the simplest solution. You still enjoy the simplicity of
+ the first front-end with the extended power of the new transition types.
+ This <a class="link" href="examples/SimpleWithFunctors.cpp" target="_top">tutorial</a>,
+ adapted from the earlier example does just this.</p><p>Of course, it is also possible to define states where entry and exit
+ actions are also provided as functors as these are generated by eUML and
+ both front-ends are equivalent. For example, we can define a state
+ as:</p><p><code class="code">struct Empty_Entry { </code></p><p><code class="code">template &lt;class Event,class Fsm,class State&gt; </code></p><p><code class="code">void operator()(Event const&amp;,Fsm&amp;,State&amp;) </code></p><p><code class="code"> {</code></p><p><code class="code"> ... </code></p><p><code class="code"> } </code></p><p><code class="code">}; // same for Empty_Exit</code></p><p><code class="code">struct Empty : public
+ msm::front::euml::func_state&lt;Empty_Entry,Empty_Exit&gt;{};</code></p><p>This also means that you can, like in the transition table, write entry /
+ exit actions made of more complicated action combinations. The previous
+ example can therefore <a class="link" href="examples/SimpleWithFunctors2.cpp" target="_top">be
+ rewritten</a>.</p><p>Usually, however, one will probably use the standard state definition as
+ it provides the same capabilities as this front-end state definition, unless
+ one needs some of the shipped predefined functors or is a fan of functional
+ programming.</p></div><div class="sect2" title="Defining a simple state machine"><div class="titlepage"><div><div><h3 class="title"><a name="d0e2532"></a>Defining a simple state machine</h3></div></div></div><p>Like states, state machines can be defined using the previous front-end,
+ as the previous example showed, or with the functor front-end, which allows
+ you to define a state machine entry and exit functions as functors, as in
+ <a class="link" href="examples/SimpleWithFunctors2.cpp" target="_top">this
+ example</a>.</p></div><div class="sect2" title="Anonymous transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e2540"></a>Anonymous transitions</h3></div></div></div><p>Anonymous (completion) transitions are transitions without a named event.
+ We saw how this front-end uses <code class="code">none</code> when no action or guard is
+ required. We can also use <code class="code">none</code> instead of an event to mark an
+ anonymous transition. For example, the following transition makes an
+ immediate transition from State1 to State2:</p><p>Row &lt; State1 , none , State2 &gt;</p><p>The following transition does the same but calling an action in the
+ process:</p><p>Row &lt; State1 , none , State2 , State1ToState2, none &gt;</p><p>The following diagram shows an example and its <a class="link" href="examples/AnonymousTutorialWithFunctors.cpp" target="_top">implementation</a>:</p><p><span class="inlinemediaobject"><img src="../images/Anonymous.jpg" width="70%"></span></p></div><div class="sect2" title="Internal transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e2566"></a><span class="command"><strong><a name="functor-internal-transitions"></a></strong></span>Internal
+ transitions</h3></div></div></div><p>The <a class="link" href="examples/SimpleTutorialInternalFunctors.cpp" target="_top">following example</a> uses internal transitions with the functor
+ front-end. As for the simple standard front-end, both methods of defining
+ internal transitions are supported:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>providing a <code class="code">Row</code> in the state machine's transition
+ table with <code class="code">none</code> as target state defines an internal
+ transition.</p></li><li class="listitem"><p>providing an <code class="code">internal_transition_table</code> made of
+ <code class="code">Internal</code> rows inside a state or submachine
+ defines UML-conform internal transitions with higher
+ priority.</p></li><li class="listitem"><p>transitions defined inside
+ <code class="code">internal_transition_table</code> require no source or
+ target state as the source state is known (<code class="code">Internal</code>
+ really are <code class="code">Row</code> without a source or target state)
+ .</p></li></ul></div><p>Like for the <span class="command"><strong><a class="command" href="ch03s02.html#internal-transitions-note">standard front-end internal transitions</a></strong></span>, internal transition
+ tables are added into the main state machine's table, thus allowing you to
+ distribute the transition table definition and reuse states.</p><p>There is an added bonus offered for submachines, which can have both the
+ standard transition_table and an internal_transition_table (which has higher
+ priority). This makes it easier if you decide to make a full submachine from
+ a state later. It is also slightly faster than the standard alternative,
+ adding orthogonal regions, because event dispatching will, if accepted by
+ the internal table, not continue to the subregions. This gives you a O(1)
+ dispatch instead of O(number of regions). While the example is with eUML,
+ the same is also possible with this front-end.</p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Basic front-end&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;eUML (experimental)</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch03s04.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch03s04.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,453 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>eUML (experimental)</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Tutorial"><link rel="prev" href="ch03s03.html" title="Functor front-end"><link rel="next" href="ch03s05.html" title="Back-end"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">eUML (experimental)</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Tutorial</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="eUML (experimental)"><div class="titlepage"><div><div><h2 class="title" style="clea
r: both"><a name="d0e2612"></a><span class="command"><strong><a name="eUML-front-end"></a></strong></span>eUML (experimental)</h2></div></div></div><p><span class="underline">Important note</span>: eUML requires a compiler
+ supporting the C++0x decltype/typeof feature (for example VC &gt;= 9, g++ &gt;= 4.3.
+ VC8 supports eUML but will crash with middle-size state machines). More
+ generally, eUML has experimental status because most compilers will start
+ crashing when a state machine becomes too big. Only g++ 4.3 (unfortunately not
+ 4.4 which shows a serious regression) seems perfectly resilient.</p><p>The previous front-ends are simple to write but still force an amount of
+ noise, mostly MPL types, so it would be nice to write code looking like C++
+ (with a C++ action language) directly inside the transition table, like UML
+ designers like to do on their state machine diagrams. If it were functional
+ programming, it would be even better. This is what eUML is for.</p><p>eUML is a Boost.Proto and Boost.Typeof-based compile-time domain specific
+ embedded language. It provides grammars which allow the definition of
+ actions/guards directly inside the transition table or entry/exit in the state
+ definition. There are grammars for actions, guards, flags, attributes, deferred
+ events, initial states.</p><p>It also relies on Boost.Typeof as a wrapper around the new decltype C++0x
+ feature to provide a compile-time evaluation of all the grammars. Unfortunately,
+ all the underlying Boost libraries are not Typeof-enabled, so for the moment,
+ you will need a compiler where Typeof is natively implemented (like VC8-9-10,
+ g++ &gt;= 4.3).</p><p>Examples will be provided in the next paragraphs. You need to include eUML
+ basic features: </p><p><code class="code">#include &lt;msm/front/euml/euml.hpp&gt;</code></p><p>To add STL support (at possible cost of longer compilation times), include: </p><p><code class="code">#include &lt;msm/front/euml/stl.hpp&gt;</code></p><p>eUML is defined in the namespace <code class="code">msm::front::euml</code>.</p><div class="sect2" title="Transition table"><div class="titlepage"><div><div><h3 class="title"><a name="d0e2641"></a>Transition table</h3></div></div></div><p>A transition can be defined using eUML as: </p><p><code class="code">source + event [guard] / action == target</code>
+ </p><p>or as</p><p><code class="code">target == source + event [guard] / action</code></p><p>The first version looks like a drawn transition in a diagram, the second
+ one seems natural to a C++ developer.</p><p>The simple transition table written with the <span class="command"><strong><a class="command" href="ch03s03.html#functor-front-end">previous front-end</a></strong></span> can now be
+ written as:</p><p>
+ </p><table frame="void" id="d0e2664"><tbody><tr>
+ <td>BOOST_MSM_EUML_TRANSITION_TABLE(( </td>
+ <td> </td>
+ </tr><tr>
+ <td>Stopped +</td>
+ <td>play [DummyGuard] / (TestFct,start_playback)</td>
+ <td>== Playing</td>
+ </tr><tr>
+ <td>Stopped +</td>
+ <td>open_close/ open_drawer</td>
+ <td>== Open</td>
+ </tr><tr>
+ <td>Stopped +</td>
+ <td>stop</td>
+ <td>== Stopped</td>
+ </tr><tr>
+ <td>Open +</td>
+ <td>open_close / close_drawer</td>
+ <td>== Empty</td>
+ </tr><tr>
+ <td>Empty +</td>
+ <td>open_close / open_drawer </td>
+ <td>== Open</td>
+ </tr><tr>
+ <td>Empty +</td>
+ <td>cd_detected [good_disk_format] / store_cd_info </td>
+ <td>== Stopped</td>
+ </tr><tr>
+ <td>),transition_table)</td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p>Or, using the alternative notation, it can be:</p><p>
+ </p><table id="d0e2756"><tbody><tr>
+ <td>BOOST_MSM_EUML_TRANSITION_TABLE((</td>
+ <td> </td>
+ <td> </td>
+ </tr><tr>
+ <td>Playing == </td>
+ <td>Stopped +</td>
+ <td>play [DummyGuard] / (TestFct,start_playback)</td>
+ </tr><tr>
+ <td>Open ==</td>
+ <td>Stopped +</td>
+ <td>open_close/ open_drawer</td>
+ </tr><tr>
+ <td>Stopped ==</td>
+ <td>Stopped +</td>
+ <td>stop</td>
+ </tr><tr>
+ <td>Empty ==</td>
+ <td>Open +</td>
+ <td>open_close / close_drawer</td>
+ </tr><tr>
+ <td>Open ==</td>
+ <td>Empty +</td>
+ <td>open_close / open_drawer</td>
+ </tr><tr>
+ <td>Stopped ==</td>
+ <td>Empty +</td>
+ <td>cd_detected [good_disk_format] / store_cd_info </td>
+ </tr><tr>
+ <td>),transition_table)</td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p>The transition table now looks like a list of (readable) rules with little
+ noise.</p><p>UML defines guards between &#8220;[ ]&#8221; and actions after a &#8220;/&#8221;, so the chosen
+ syntax is already more readable for UML designers. UML also allows designers
+ to define several actions sequentially (our previous ActionSequence_)
+ separated by a comma. The first transition does just this: two actions
+ separated by a comma and enclosed inside parenthesis to respect C++ operator
+ precedence.</p><p>If this seems to you like it will cost you run-time performance, don't
+ worry, eUML is based on typeof (decltype) which only evaluates the
+ parameters to BOOST_MSM_EUML_TRANSITION_TABLE and no run-time cost occurs.
+ Actually, eUML is only a metaprogramming layer on top of "standard" MSM
+ metaprogramming and this first layer generates the previously-introduced
+ <span class="command"><strong><a class="command" href="ch03s03.html#functor-front-end">functor
+ front-end</a></strong></span>.</p><p>UML also allows designers to define more complicated guards, like
+ [good_disk_format &amp;&amp; (some_condition || some_other_condition)]. This
+ was possible with our previously defined functors, but using a complicated
+ template syntax. This syntax is now possible exactly as written, which means
+ without any syntactic noise at all.</p></div><div class="sect2" title="Defining events, actions and states with entry/exit actions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e2858"></a>Defining events, actions and states with entry/exit actions</h3></div></div></div><div class="sect3" title="Events"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2861"></a>Events</h4></div></div></div><p>Events must be proto-enabled. To achieve this, they must inherit from
+ a proto terminal (euml_event&lt;event-name&gt;). eUML also provides a macro
+ to make this easier:</p><p><code class="code">BOOST_MSM_EUML_EVENT(play)</code></p><p>This declares an event type and an instance of this type called
+ <code class="code">play</code>, which is now ready to use in state or transition
+ behaviors.</p><p>There is a second macro, BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES, which
+ takes as second parameter the attributes an event will contain, using
+ the <span class="command"><strong><a class="command" href="ch03s04.html#eUML-attributes">attribute
+ syntax</a></strong></span>.</p><p><span class="underline">Note</span>: as we now have events
+ defined as instances instead of just types, can we still process an
+ event by creating one on the fly, like:
+ <code class="code">fsm.process_event(play());</code> or do we have to write:
+ <code class="code">fsm.process_event(play);</code></p><p>The answer is you can do both. The second one is easier but unlike
+ other front-ends, the second uses a defined operator(), which creates an
+ event on the fly.</p></div><div class="sect3" title="Actions"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2890"></a>Actions</h4></div></div></div><p>Actions (returning void) and guards (returning a bool) are defined
+ like previous functors, with the difference that they also must be
+ proto-enabled. This can be done by inheriting from euml_action&lt;
+ functor-name &gt;. eUML also provides a macro:</p><p><code class="code">BOOST_MSM_EUML_ACTION(some_condition)</code></p><p><code class="code">{ </code></p><p><code class="code">template &lt;class Fsm,class Evt,class SourceState,class
+ TargetState&gt;</code></p><p><code class="code">bool operator()(Evt const&amp; ,Fsm&amp; ,SourceState&amp;
+ ,TargetState&amp; ) { return true; } </code></p><p><code class="code">}; </code></p><p>Like for events, this macro declares a functor type and an instance
+ for use in transition or state behaviors.</p><p>It is possible to use the same action grammar from the transition
+ table to define state entry and exit behaviors. So
+ <code class="code">(action1,action2)</code> is a valid entry or exit behavior
+ executing both actions in turn.</p><p>The state functors have a slightly different signature as there is no
+ source and target state but only a current state (entry/exit actions are
+ transition-independent), for example:</p><p><code class="code">BOOST_MSM_EUML_ACTION(Empty_Entry)</code></p><p><code class="code">{ </code></p><p><code class="code">template &lt;class Evt,class Fsm,class State&gt;</code></p><p><code class="code">void operator()(Evt const&amp; ,Fsm&amp; ,State&amp; ) { ... }
+ </code></p><p><code class="code">}; </code></p></div><div class="sect3" title="States"><div class="titlepage"><div><div><h4 class="title"><a name="d0e2934"></a>States</h4></div></div></div><p>There is also a macro for states. This macro has 2 arguments, first
+ the expression defining the state, then the state (instance)
+ name:</p><p><code class="code">BOOST_MSM_EUML_STATE((),Paused)</code></p><p>This defines a simple state without entry or exit action. You can
+ provide in the expression parameter the state behaviors (entry and exit)
+ using the action grammar, like in the transition table:</p><p><code class="code">BOOST_MSM_EUML_STATE(((Empty_Entry,Dummy_Entry)/*2 entry
+ actions*/,Empty_Exit/*1 exit action*/ ),Empty)</code></p><p>This means that Empty is defined as a state with an entry action made
+ of two sub-actions, Empty_Entry and Dummy_Entry (enclosed inside
+ parenthesis), and an exit action, Empty_Exit.</p><p>There are several possibilitites for the <span class="command"><strong><a name="eUML-build-state"></a></strong></span> expression syntax:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>(): state without entry or exit action.</p></li><li class="listitem"><p>(Expr1): state with entry but no exit action.</p></li><li class="listitem"><p>(Expr1,Expr2): state with entry and exit action.</p></li><li class="listitem"><p>(Expr1,Expr2,Attributes): state with entry and exit
+ action, defining some attributes (read further on).</p></li><li class="listitem"><p>(Expr1,Expr2,Attributes,Configure): state with entry and
+ exit action, defining some attributes (read further on) and
+ flags (standard MSM flags) or deferred events (standard MSM
+ deferred events).</p></li><li class="listitem"><p>(Expr1,Expr2,Attributes,Configure,Base): state with entry
+ and exit action, defining some attributes (read further on),
+ flags and deferred events (plain msm deferred events) and a
+ non-default base state (as defined in standard MSM).</p></li></ul></div><p>no_action is also defined, which does, well, nothing except being a
+ placeholder (needed for example as entry action if we have no entry but
+ an exit). Expr1 and Expr2 are a sequence of actions, obeying the same
+ action grammar as in the transition table (following the &#8220;/&#8221;
+ symbol).</p><p>The BOOST_MSM_EUML_STATE macro will allow you to define most common
+ states, but sometimes you will need more, for example provide in your
+ states some special behavior. In this case, you will have to do the
+ macro's job by hand, which is not very complicated. The state will need
+ to inherit from <code class="code">msm::front::state&lt;&gt;</code>, like any state, and
+ from <code class="code">euml_statestate-name&gt;</code> to be proto-enabled. You will
+ then need to declare an instance for use in the transition table. For
+ example:</p><p><code class="code">struct Empty_impl : public msm::front::state&lt;&gt; , public
+ euml_state&lt;Empty_impl&gt; {</code></p><p><code class="code">void activate_empty() {std::cout &lt;&lt; "switching to Empty "
+ &lt;&lt; std::endl;}</code></p><p><code class="code">template &lt;class Event,class Fsm&gt;</code></p><p><code class="code">void on_entry(Event const&amp; evt,Fsm&amp;
+ fsm){...}</code></p><p><code class="code">template &lt;class Event,class Fsm&gt; </code></p><p><code class="code">void on_exit(Event const&amp; evt,Fsm&amp;
+ fsm){...}</code></p><p><code class="code">};</code></p><p><code class="code">//instance for use in the transition table</code></p><p><code class="code">Empty_impl const Empty;</code></p><p>Notice also that we defined a method named activate_empty. We would
+ like to call it inside a behavior. This can be done using the
+ BOOST_MSM_EUML_METHOD macro. </p><p><code class="code">BOOST_MSM_EUML_METHOD(ActivateEmpty_ , activate_empty ,
+ activate_empty_ , void , void )</code></p><p>The first parameter is the name of the underlying functor, which you
+ could use with the functor front-end, the second is the state method
+ name, the third is the eUML-generated function, the fourth and fifth the
+ return value when used inside a transition or a state behavior. You can
+ now use this inside a transition:</p><p><code class="code">Empty == Open + open_close /
+ (close_drawer,activate_empty_(target_))</code></p></div></div><div class="sect2" title="Defining a simple state machine"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3019"></a>Defining a simple state machine</h3></div></div></div><p>You can reuse the state machine definition method from the standard
+ front-end and simply replace the transition table by this new one. You can
+ also use eUML to define a state machine "on the fly" (if, for example, you
+ need to provide an on_entry/on_exit for this state machine as a functor).
+ For this, there is also a macro, <span class="command"><strong><a name="eUML-build-sm"></a></strong></span>BOOST_MSM_EUML_DECLARE_STATE_MACHINE, which has 2 arguments, an expression
+ describing the state machine and the state machine name. The expression has
+ up to 8 arguments:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>(Stt, Init): simplest state machine where only the transition
+ table and initial state(s) are defined.</p></li><li class="listitem"><p>(Stt, Init, Expr1): state machine where the transition table,
+ initial state and entry action are defined.</p></li><li class="listitem"><p>(Stt, Init, Expr1, Expr2): state machine where the transition
+ table, initial state, entry and exit actions are defined.</p></li><li class="listitem"><p>(Stt, Init, Expr1, Expr2, Attributes): state machine where the
+ transition table, initial state, entry and exit actions are
+ defined. Furthermore, some attributes are added (read further
+ on).</p></li><li class="listitem"><p>(Stt, Init, Expr1, Expr2, Attributes, Configure): state
+ machine where the transition table, initial state, entry and
+ exit actions are defined. Furthermore, some attributes (read
+ further on), flags, deferred events and <a class="link" href="ch03s04.html#eUML-Configuration">configuration
+ capabilities</a> (no message queue / no exception
+ catching) are added.</p></li><li class="listitem"><p>(Stt, Init, Expr1, Expr2, Attributes, Flags, Deferred , Base):
+ state machine where the transition table, initial state, entry
+ and exit actions are defined. Furthermore, attributes (read
+ further on), flags , deferred events and configuration
+ capabilities (no message queue / no exception catching) are
+ added and a non-default base state (see the <a class="link" href="ch03s05.html#backend-base-state">back-end
+ description</a>) is defined.</p></li></ul></div><p>For example, a minimum state machine could be defined
+ as:</p><p>
+ </p><table id="d0e3054"><tbody><tr>
+ <td>BOOST_MSM_EUML_TRANSITION_TABLE((</td>
+ <td> </td>
+ <td> </td>
+ </tr><tr>
+ <td>),transition_table)</td>
+ <td> </td>
+ <td> </td>
+ </tr></tbody></table><p>
+ </p><p><code class="code">BOOST_MSM_EUML_DECLARE_STATE_MACHINE((transition_table,init_
+ &lt;&lt; Empty ),player_)</code></p><p>Please have a look at the player tutorial written using eUML's <a class="link" href="examples/SimpleTutorialEuml2.cpp" target="_top">first</a> and <a class="link" href="examples/SimpleTutorialEuml.cpp" target="_top">second</a> syntax. The
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE macro, to which we will get back shortly,
+ declares attributes given to an eUML type (state or event) using the
+ <span class="command"><strong><a class="command" href="ch03s04.html#eUML-attributes">attribute
+ syntax</a></strong></span>.</p></div><div class="sect2" title="Defining a submachine"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3093"></a>Defining a submachine</h3></div></div></div><p>Defining a submachine (see <a class="link" href="examples/CompositeTutorialEuml.cpp" target="_top">tutorial</a>) with
+ other front-ends simply means using a state which is a state machine in the
+ transition table of another state machine. This is the same with eUML. One
+ only needs define a second state machine and reference it in the transition
+ table of the containing state machine.</p><p>Unlike the state or event definition macros,
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE defines a type, not an instance because
+ a type is what the back-end requires. This means that you will need to
+ declare yourself an instance to reference your submachine into another state
+ machine, for example:</p><p><code class="code">BOOST_MSM_EUML_DECLARE_STATE_MACHINE(...,Playing_)</code></p><p><code class="code">typedef msm::back::state_machine&lt;Playing_&gt;
+ Playing_type;</code></p><p><code class="code">Playing_type const Playing;</code></p><p>We can now use this instance inside the transition table of the containing
+ state machine:</p><p><code class="code">Paused == Playing + pause / pause_playback</code></p></div><div class="sect2" title="Attributes / Function call"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3117"></a>
+ <span class="command"><strong><a name="eUML-attributes"></a></strong></span>Attributes / Function call</h3></div></div></div><p>We now want to make our grammar more useful. Very often, one needs only
+ very simple action methods, for example ++Counter or Counter &gt; 5 where
+ Counter is usually defined as some attribute of the class containing the
+ state machine. It seems like a waste to write a functor for such a simple
+ action. Furthermore, states within MSM are also classes so they can have
+ attributes, and we would also like to provide them with attributes. </p><p>If you look back at our examples using the <a class="link" href="examples/SimpleTutorialEuml2.cpp" target="_top">first</a> and <a class="link" href="examples/SimpleTutorialEuml.cpp" target="_top">second</a> syntaxes, you
+ will find a BOOST_MSM_EUML_DECLARE_ATTRIBUTE and a BOOST_MSM_EUML_ATTRIBUTES
+ macro. The first one declares possible attributes:</p><p><code class="code">BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,cd_name)</code></p><p><code class="code">BOOST_MSM_EUML_DECLARE_ATTRIBUTE(DiskTypeEnum,cd_type)</code></p><p>This declares two attributes: cd_name of type std::string and cd_type of
+ type DiskTypeEnum. These attributes are not part of any event or state in
+ particular, we just declared a name and a type. Now, we can add attributes
+ to our cd_detected event using the second one:</p><p><code class="code">BOOST_MSM_EUML_ATTRIBUTES((attributes_ &lt;&lt; cd_name &lt;&lt;
+ cd_type ), cd_detected_attributes)</code></p><p>This declares an attribute list which is not linked to anything in
+ particular yet. It can be attached to a state or an event. For example, if
+ we want the event cd_detected to have these defined attributes we
+ write:</p><p><code class="code">BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(cd_detected,cd_detected_attributes)</code></p><p>For states, we use the BOOST_MSM_EUML_STATE macro, which has an expression
+ form where one can provide attributes. For example:</p><p><code class="code">BOOST_MSM_EUML_STATE((no_action /*entry*/,no_action/*exit*/,
+ attributes_ &lt;&lt; cd_detected_attributes),some_state)</code></p><p>OK, great, we now have a way to add attributes to a class, which we could
+ have done more easily, so what is the point? The point is that we can now
+ reference these attributes directly, at compile-time, in the transition
+ table. For example, in the example, you will find this transition:</p><p><code class="code">Stopped == Empty + cd_detected [good_disk_format &amp;&amp;
+ (event_(cd_type)==Int_&lt;DISK_CD&gt;())] </code></p><p>Read event_(cd_type) as event_-&gt;cd_type with event_ a type generic for
+ events, whatever the concrete event is (in this particular case, it happens
+ to be a cd_detected as the transition shows).</p><p>The main advantage of this feature is that you do not need to define a new
+ functor and you do not need to look inside the functor to know what it does,
+ you have all at hand.</p><p>MSM provides more generic objects for state machine types:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>event_ : used inside any action, the event triggering the
+ transition</p></li><li class="listitem"><p>state_: used inside entry and exit actions, the entered /
+ exited state</p></li><li class="listitem"><p>source_: used inside a transition action, the source
+ state</p></li><li class="listitem"><p>target_: used inside a transition action, the target
+ state</p></li><li class="listitem"><p>fsm_: used inside any action, the (lowest-level) state machine
+ processing the transition</p></li><li class="listitem"><p>Int_&lt;int value&gt;: a functor representing an int</p></li><li class="listitem"><p>Char_&lt;value&gt;: a functor representing a char</p></li><li class="listitem"><p>Size_t_&lt;value&gt;: a functor representing a size_t</p></li><li class="listitem"><p>String_&lt;mpl::string&gt; (boost &gt;= 1.40): a functor
+ representing a string.</p></li></ul></div><p>These helpers can be used in two different ways:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>helper(attribute_name) returns the attribute with name
+ attribute_name</p></li><li class="listitem"><p>helper returns the state / event type itself.</p></li></ul></div><p>The second form is helpful if you want to provide your states with their
+ own methods, which you also want to use inside the transition table. In the
+ <a class="link" href="examples/SimpleTutorialEuml.cpp" target="_top">above
+ tutorial</a>, we provide Empty with an activate_empty method. We would
+ like to create a eUML functor and call it from inside the transition table.
+ This is done using the MSM_EUML_METHOD / MSM_EUML_FUNCTION macros. The first
+ creates a functor to a method, the second to a free function. In the
+ tutorial, we write:</p><p><code class="code">MSM_EUML_METHOD(ActivateEmpty_ , activate_empty , activate_empty_ ,
+ void , void )</code></p><p>The first parameter is the functor name, for use with the functor
+ front-end. The second is the name of the method to call. The third is the
+ function name for use with eUML, the fourth is the return type of the
+ function if used in the context of a transition action, the fifth is the
+ result type if used in the context of a state entry / exit action (usually
+ fourth and fifth are the same). We now have a new eUML function calling a
+ method of "something", and this "something" is one of the five previously
+ shown generic helpers. We can now use this in a transition, for
+ example:</p><p><code class="code">Empty == Open + open_close /
+ (close_drawer,activate_empty_(target_))</code></p><p>The action is now defined as a sequence of two actions: close_drawer and
+ activate_empty, which is called on the target itself. The target being Empty
+ (the state defined left), this really will call Empty::activate_empty().
+ This method could also have an (or several) argument(s), for example the
+ event, we could then call activate_empty_(target_ , event_).</p><p>More examples can be found in the <a class="link" href="examples/CompilerStressTestEuml.cpp" target="_top">terrible compiler
+ stress test</a>, the <a class="link" href="examples/SimpleTimer.cpp" target="_top">timer example</a> or in the <a class="link" href="examples/iPodSearchEuml.cpp" target="_top">iPodSearch with eUML</a>
+ (for String_ and more).</p></div><div class="sect2" title="Orthogonal regions, flags, event deferring"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3227"></a>Orthogonal regions, flags, event deferring</h3></div></div></div><p>Defining orthogonal regions really means providing more initial states. To
+ add more initial states, &#8220;shift left&#8221; some, for example, if we had another
+ initial state named AllOk :</p><p><code class="code">BOOST_MSM_EUML_DECLARE_STATE_MACHINE((transition_table,init_
+ &lt;&lt; Empty &lt;&lt; AllOk ),player_)</code></p><p>You remember from the <span class="command"><strong><a class="command" href="ch03s04.html#eUML-build-state">BOOST_MSM_EUML_STATE </a></strong></span> and <span class="command"><strong><a class="command" href="ch03s04.html#eUML-build-sm">BOOST_MSM_EUML_DECLARE_STATE_MACHINE</a></strong></span> signatures that just
+ after attributes, we can define flags, like in the basic MSM front-end. To
+ do this, we have another "shift-left" grammar, for example:</p><p><code class="code">BOOST_MSM_EUML_STATE((no_action,no_action, attributes_ &lt;&lt;
+ no_attributes_, </code></p><p><code class="code">/* flags */ configure_&lt;&lt; PlayingPaused &lt;&lt; CDLoaded
+ ),Paused)</code></p><p>We now defined that Paused will get two flags, PlayingPaused and CDLoaded,
+ defined, with another macro:</p><p><code class="code">BOOST_MSM_EUML_FLAG(CDLoaded)</code></p><p>This corresponds to the following basic front-end definition of
+ Paused:</p><p><code class="code">struct Paused : public msm::front::state&lt;&gt; </code></p><p><code class="code">{ typedef mpl::vector2&lt;PlayingPaused,CDLoaded&gt; flag_list; };
+ </code></p><p>Under the hood, what you get really is a mpl::vector2.</p><p><span class="underline">Note</span>: As we use the version of
+ BOOST_MSM_EUML_STATE's expression with 4 arguments, we need to tell eUML
+ that we need no attributes. Similarly to a <code class="code">cout &lt;&lt; endl</code>,
+ we need a <code class="code">attributes_ &lt;&lt; no_attributes_</code> syntax.</p><p>You can use the flag with the is_flag_active method of a state machine.
+ You can also use the provided helper function is_flag_ (returning a bool)
+ for state and transition behaviors. For example, in the <a class="link" href="examples/iPodEuml.cpp" target="_top">iPod implementation with eUML</a>,
+ you find the following transition:</p><p><code class="code">ForwardPressed == NoForward + EastPressed
+ [!is_flag_(NoFastFwd)]</code></p><p>The function also has an optional second parameter which is the state
+ machine on which the function is called. By default, fsm_ is used (the
+ current state machine) but you could provide a functor returning a reference
+ to another state machine.</p><p>eUML also supports defining deferred events in the state (state machine)
+ definition. To this aim, we can reuse the flag grammar. For example:</p><p><code class="code">BOOST_MSM_EUML_STATE((Empty_Entry,Empty_Exit, attributes_ &lt;&lt;
+ no_attributes_, </code></p><p><code class="code">/* deferred */ configure_&lt;&lt; play ),Empty) </code></p><p>The configure_ left shift is also responsible for deferring events. Shift
+ inside configure_ a flag and the state will get a flag, shift an event and
+ it will get a deferred event. This replaces the basic front-end
+ definition:</p><p><code class="code">typedef mpl::vector&lt;play&gt; deferred_events;</code></p><p>In <a class="link" href="examples/OrthogonalDeferredEuml.cpp" target="_top">this
+ tutorial</a>, player is defining a second orthogonal region with
+ AllOk as initial state. The <code class="code">Empty</code> and <code class="code">Open</code> states
+ also defer the event <code class="code">play</code>. <code class="code">Open</code>,
+ <code class="code">Stopped</code> and <code class="code">Pause</code> also support the flag
+ <code class="code">CDLoaded</code> using the same left shift into
+ <code class="code">configure_</code>.</p><p>In the functor front-end, we also had the possibility to defer an event
+ inside a transition, which makes possible conditional deferring. This is
+ also possible with eUML through the use of the defer_ order, as shown in
+ <a class="link" href="examples/OrthogonalDeferredEuml.cpp" target="_top">this
+ tutorial</a>. You will find the following transition:</p><p><code class="code">Open + play / defer_</code></p><p>This is an <span class="command"><strong><a class="command" href="ch03s04.html#eUML-internal">internal
+ transition</a></strong></span>. Ignore it for the moment. Interesting is, that
+ when the event <code class="code">play</code> is fired and <code class="code">Open</code> is active,
+ the event will be deferred. Now add a guard and you can conditionally defer
+ the event, for example:</p><p><code class="code">Open + play [ some_condition ] / defer_</code></p><p>This is similar to what we did with the functor front-end. This means that
+ we have the same constraints. Using defer_ instead of a state declaration,
+ we need to tell MSM that we have deferred events in this state machine. We
+ do this (again) using a configure_ declaration in the state machine
+ definition in which we shift the deferred_events configuration flag:</p><p><code class="code">BOOST_MSM_EUML_DECLARE_STATE_MACHINE((transition_table,init_
+ &lt;&lt; Empty &lt;&lt; AllOk,</code></p><p><code class="code">Entry_Action, Exit_Action, attributes_ &lt;&lt; no_attributes_,
+ configure_&lt;&lt; deferred_events ),player_)</code></p><p>A <a class="link" href="examples/OrthogonalDeferredEuml2.cpp" target="_top">tutorial</a>
+ illustrates this possibility.</p></div><div class="sect2" title="Customizing a state machine / Getting more speed"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3361"></a>
+ <span class="command"><strong><a name="eUML-Configuration"></a></strong></span>Customizing a state machine / Getting
+ more speed</h3></div></div></div><p>We just saw how to use configure_ to define deferred events or flags. We
+ can also use it to configure our state machine like we did with the other front-ends:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">configure_ &lt;&lt; no_exception</code>: disables
+ exception handling</p></li><li class="listitem"><p><code class="code">configure_ &lt;&lt; no_msg_queue</code> deactivates the
+ message queue</p></li><li class="listitem"><p><code class="code">configure_ &lt;&lt; deferred_events</code> manually
+ enables event deferring</p></li></ul></div><p>Deactivating the first two features and not activating the third if not
+ needed greatly improves the event dispatching speed of your state machine.
+ Our <a class="link" href="examples/EumlSimple.cpp" target="_top">speed testing</a> example
+ with eUML does this for the best performance.</p></div><div class="sect2" title="Completion / Anonymous transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3389"></a>Completion / Anonymous transitions</h3></div></div></div><p>Anonymous transitions (See <span class="command"><strong><a class="command" href="ch02s02.html#uml-anonymous">UML
+ tutorial</a></strong></span>) are transitions without a named event, which are
+ therefore triggered immediately when the source state becomes active,
+ provided a guard allows it. As there is no event, to define such a
+ transition, simply omit the &#8220;+&#8221; part of the transition (the event), for
+ example: </p><p><code class="code">State3 == State4 [always_true] / State3ToState4</code></p><p><code class="code">State4 [always_true] / State3ToState4 == State3</code></p><p>Please have a look at <a class="link" href="examples/AnonymousTutorialEuml.cpp" target="_top">this example</a>,
+ which implements the <span class="command"><strong><a class="command" href="ch03s02.html#anonymous-transitions">previously
+ defined</a></strong></span> state machine with eUML.</p></div><div class="sect2" title="Internal transitions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3411"></a><span class="command"><strong><a name="eUML-internal"></a></strong></span>Internal transitions</h3></div></div></div><p>Like both other front-ends, eUML supports two ways of defining internal transitions:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>in the state machine's transition table. In this case, you
+ need to specify a source state, event, actions and guards but no
+ target state, which eUML will interpret as an internal
+ transition, for example this defines a transition internal to
+ Open, on the event open_close:</p><p><code class="code">Open + open_close [internal_guard1] /
+ internal_action1</code></p><p><a class="link" href="examples/EumlInternal.cpp" target="_top">A full
+ example</a> is also provided.</p></li><li class="listitem"><p>in a state's <code class="code">internal_transition_table</code>. For
+ example:</p><p><code class="code">BOOST_MSM_EUML_DECLARE_STATE((Open_Entry,Open_Exit),Open_def)</code></p><p><code class="code">struct Open_impl : public Open_def</code></p><p><code class="code">BOOST_MSM_EUML_DECLARE_INTERNAL_TRANSITION_TABLE((</code></p><p><code class="code">open_close [internal_guard1] /
+ internal_action1</code></p><p><code class="code">))</code></p><p>Notice how we do not need to repeat that the transition
+ originates from Open as we already are in Open's context. </p><p>The <a class="link" href="examples/EumlInternalDistributed.cpp" target="_top">implementation</a> also shows the added bonus offered
+ for submachines, which can have both the standard
+ transition_table and an internal_transition_table (which has
+ higher priority). This makes it easier if you decide to make a
+ full submachine from a state. It is also slightly faster than
+ the standard alternative, adding orthogonal regions, because
+ event dispatching will, if accepted by the internal table, not
+ continue to the subregions. This gives you a O(1) dispatch
+ instead of O(number of regions).</p></li></ul></div></div><div class="sect2" title="Other state types"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3456"></a>Other state types</h3></div></div></div><p>We saw the <span class="command"><strong><a class="command" href="ch03s04.html#eUML-build-state">build_state</a></strong></span>
+ function, which creates a simple state. Likewise, eUML provides other
+ state-building macros for other types of states:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>BOOST_MSM_EUML_TERMINATE_STATE takes the same arguments as
+ BOOST_MSM_EUML_STATE and defines, well, a terminate
+ state.</p></li><li class="listitem"><p>BOOST_MSM_EUML_INTERRUPT_STATE takes the same arguments as
+ BOOST_MSM_EUML_STATE and defines an interrupt state. However,
+ the expression argument must contain as first element the event
+ ending the interruption, for example:
+ <code class="code">BOOST_MSM_EUML_INTERRUPT_STATE(( end_error /*end
+ interrupt event*/,ErrorMode_Entry,ErrorMode_Exit
+ ),ErrorMode)</code></p></li><li class="listitem"><p>BOOST_MSM_EUML_EXIT_STATE takes the same arguments as
+ BOOST_MSM_EUML_STATE and defines an exit pseudo state. However,
+ the expression argument must contain as first element the event
+ propagated from the exit point:
+ <code class="code">BOOST_MSM_EUML_EXIT_STATE(( event6 /*propagated
+ event*/,PseudoExit1_Entry,PseudoExit1_Exit
+ ),PseudoExit1)</code></p></li><li class="listitem"><p>BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE defines an entry pseudo
+ state. It takes 3 parameters: the region index to be entered is
+ defined as an int argument, followed by the configuration
+ expression like BOOST_MSM_EUML_STATE and the state name, so that
+ <code class="code">BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE(0 /*region
+ index*/,( SubState2_Entry,SubState2_Exit ),SubState2)</code>
+ defines an entry state into the first region of a
+ submachine.</p></li><li class="listitem"><p>BOOST_MSM_EUML_ENTRY_STATE defines an entry pseudo state. It
+ takes 3 parameters: the region index to be entered is defined as
+ an int argument, followed by the configuration expression like
+ BOOST_MSM_EUML_STATE and the state name, so that
+ <code class="code">BOOST_MSM_EUML_ENTRY_STATE(0,(
+ PseudoEntry1_Entry,PseudoEntry1_Exit ),PseudoEntry1)</code>
+ defines a pseudo entry state into the first region of a
+ submachine.</p></li></ul></div><p>To use these states in the transition table, eUML offers the functions
+ <code class="code">explicit_</code>, <code class="code">exit_pt_</code> and
+ <code class="code">entry_pt_</code>. For example, a direct entry into the substate
+ SubState2 from SubFsm2 could be:</p><p><code class="code">explicit_(SubFsm2,SubState2) == State1 + event2</code></p><p>Forks being a list on direct entries, eUML supports a logical syntax
+ (state1, state2, ...), for example:</p><p><code class="code">(explicit_(SubFsm2,SubState2), explicit_(SubFsm2,SubState2b),
+ explicit_(SubFsm2,SubState2c)) == State1 + event3 </code></p><p>An entry point is entered using the same syntax as explicit entries:
+ <code class="code">entry_pt_(SubFsm2,PseudoEntry1) == State1 + event4</code></p><p>For exit points, it is again the same syntax except that exit points are
+ used as source of the transition: <code class="code">State2 ==
+ exit_pt_(SubFsm2,PseudoExit1) + event6 </code></p><p>The <a class="link" href="examples/DirectEntryEuml.cpp" target="_top">entry tutorial</a>
+ is also available with eUML.</p></div><div class="sect2" title="Helper functions"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3522"></a>Helper functions</h3></div></div></div><p>We saw a few helpers but there are more, so let us have a more complete description:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>event_ : used inside any action, the event triggering the
+ transition</p></li><li class="listitem"><p>state_: used inside entry and exit actions, the entered /
+ exited state</p></li><li class="listitem"><p>source_: used inside a transition action, the source
+ state</p></li><li class="listitem"><p>target_: used inside a transition action, the target
+ state</p></li><li class="listitem"><p>fsm_: used inside any action, the (deepest-level) state
+ machine processing the transition</p></li><li class="listitem"><p>These objects can also be used as a function and return an
+ attribute, for example event_(cd_name)</p></li><li class="listitem"><p>Int_&lt;int value&gt;: a functor representing an int</p></li><li class="listitem"><p>Char_&lt;value&gt;: a functor representing a char</p></li><li class="listitem"><p>Size_t_&lt;value&gt;: a functor representing a size_t</p></li><li class="listitem"><p>True_ and False_ functors returning true and false
+ respectively</p></li><li class="listitem"><p>String_&lt;mpl::string&gt; (boost &gt;= 1.40): a functor
+ representing a string.</p></li><li class="listitem"><p>if_then_else_(guard, action, action) where action can be an
+ action sequence</p></li><li class="listitem"><p>if_then_(guard, action) where action can be an action
+ sequence</p></li><li class="listitem"><p>while_(guard, action) where action can be an action
+ sequence</p></li><li class="listitem"><p>do_while_(guard, action) where action can be an action
+ sequence</p></li><li class="listitem"><p>for_(action, guard, action, action) where action can be an
+ action sequence</p></li><li class="listitem"><p>process_(some_event [, some state machine] [, some state
+ machine] [, some state machine] [, some state machine]) will
+ call process_event (some_event) on the current state machine or
+ on the one(s) passed as 2nd , 3rd, 4th, 5th argument. This allow
+ sending events to several external machines</p></li><li class="listitem"><p>process2_(some_event,Value [, some state machine] [, some
+ state machine] [, some state machine]) will call process_event
+ (some_event(Value)) on the current state machine or on the
+ one(s) passed as 3rd, 4th, 5th argument</p></li><li class="listitem"><p>is_ flag_(some_flag[, some state machine]) will call
+ is_flag_active on the current state machine or on the one passed
+ as 2nd argument</p></li><li class="listitem"><p>Predicate_&lt;some predicate&gt;: Used in STL algorithms. Wraps
+ unary/binary functions to make them eUML-compatible so that they
+ can be used in STL algorithms</p></li></ul></div><p>This can be quite fun. For example, </p><p><code class="code">/( if_then_else_(--fsm_(m_SongIndex) &gt; Int_&lt;0&gt;(),/*if
+ clause*/</code></p><p><code class="code">show_playing_song(), /*then clause*/</code></p><p><code class="code">(fsm_(m_SongIndex)=Int_&lt;1&gt;(),process_(EndPlay())) /*else clause*/
+ ) )</code> means:</p><p>if (fsm.SongIndex &gt; 0, call show_playing_song else {fsm.SongIndex=1;
+ process EndPlay on fsm;}</p><p>A few examples are using these features:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>the iPod example introduced at the BoostCon09 <a class="link" href="examples/iPodEuml.cpp" target="_top">has been rewritten</a>
+ with eUML (weak compilers please move on...)</p></li><li class="listitem"><p>the iPodSearch example also introduced at the BoostCon09 <a class="link" href="examples/iPodSearchEuml.cpp" target="_top">has been
+ rewritten</a> with eUML. In this example, you will also
+ find some examples of STL functor usage.</p></li><li class="listitem"><p><a class="link" href="examples/SimpleTimer.cpp" target="_top">A simpler
+ timer</a> example is a good starting point. </p></li></ul></div><p>There is unfortunately a small catch. Defining a functor using
+ MSM_EUML_METHOD or MSM_EUML_FUNCTION will create a correct functor. Your own
+ eUML functors written as described at the beginning of this section will
+ also work well, <span class="underline">except</span>, for the
+ moment, with the while_, if_then_, if_then_else_ functions.</p></div><div class="sect2" title="Phoenix-like STL support"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3627"></a>Phoenix-like STL support</h3></div></div></div><p>eUML supports most C++ operators (except address-of). For example it is
+ possible to write event_(some_attribute)++ or [source_(some_bool) &amp;&amp;
+ fsm_(some_other_bool)]. But a programmer needs more than operators in his
+ daily programming. The STL is clearly a must have. Therefore, eUML comes in
+ with a lot of functors to further reduce the need for your own functors for
+ the transition table. For almost every algorithm or container method of the
+ STL, a corresponding eUML function is defined. Like Boost.Phoenix, &#8220;.&#8221; And
+ &#8220;-&gt;&#8221; of call on objects are replaced by a functional programming paradigm,
+ for example:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>begin_(container), end_(container): return iterators of a
+ container.</p></li><li class="listitem"><p>empty_(container): returns container.empty()</p></li><li class="listitem"><p>clear_(container): container.clear()</p></li><li class="listitem"><p>transform_ : std::transform</p></li></ul></div><p>In a nutshell, almost every STL method or algorithm is matched by a
+ corresponding functor, which can then be used in the transition table or
+ state actions. The <a class="link" href="pt02.html#Reference-begin">reference</a>
+ lists all eUML functions and the underlying functor (so that this
+ possibility is not reserved to eUML but also to the functor-based
+ front-end). The file structure of this Phoenix-like library matches the one
+ of Boost.Phoenix. All functors for STL algorithms are to be found in:</p><p><code class="code">#include &lt;msm/front/euml/algorithm.hpp&gt;</code></p><p>The algorithms are also divided into sub-headers, matching the phoenix
+ structure for simplicity:</p><p><code class="code">#include &lt; msm/front/euml/iteration.hpp&gt; </code></p><p><code class="code">#include &lt; msm/front/euml/transformation.hpp&gt; </code></p><p><code class="code">#include &lt; msm/front/euml/querying.hpp&gt; </code></p><p>Container methods can be found in:</p><p><code class="code">#include &lt; msm/front/euml/container.hpp&gt;</code></p><p>Or one can simply include the whole STL support (you will also need to
+ include euml.hpp):</p><p><code class="code">#include &lt; msm/front/euml/stl.hpp&gt;</code></p><p>A few examples (to be found in <a class="link" href="examples/iPodSearchEuml.cpp" target="_top">this tutorial</a>):</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">push_back_(fsm_(m_tgt_container),event_(m_song))</code>:
+ the state machine has an attribute m_tgt_container of type
+ std::vector&lt;OneSong&gt; and the event has an attribute m_song of
+ type OneSong. The line therefore pushes m_song at the end of
+ m_tgt_container</p></li><li class="listitem"><p><code class="code">if_then_( state_(m_src_it) !=
+ end_(fsm_(m_src_container)),
+ process2_(OneSong(),*(state_(m_src_it)++)) )</code>: the
+ current state has an attribute m_src_it (an iterator). If this
+ iterator != fsm.m_src_container.end(), process OneSong on fsm,
+ copy-constructed from state.m_src_it which we
+ post-increment</p></li></ul></div></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Functor front-end&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Back-end</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch03s05.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch03s05.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,139 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Back-end</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Tutorial"><link rel="prev" href="ch03s04.html" title="eUML (experimental)"><link rel="next" href="ch04.html" title="Chapter&nbsp;4.&nbsp; Performance / Compilers"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Back-end</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Tutorial</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Back-end"><div class="titlepage"><div><div><h2 class="title" style="clea
r: both"><a name="d0e3690"></a>Back-end</h2></div></div></div><p>There is, at the moment, one back-end. This back-end contains the library
+ engine and defines the performance and functionality trade-offs. The currently
+ available back-end implements most of the functionality defined by the UML 2.0
+ standard at very high runtime speed, in exchange for longer compile-time. The
+ runtime speed is due to a constant-time double-dispatch and self-adapting
+ capabilities allowing the framework to adapt itself to the features used by a
+ given concrete state machine. All unneeded features either disable themselves or
+ can be manually disabled. See section 5.1 for a complete description of the
+ run-to-completion algorithm.</p><div class="sect2" title="Creation"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3695"></a>Creation </h3></div></div></div><p>MSM being divided between front and back-end, one needs to first define a
+ front-end. Then, to create a real state machine, the back-end must be
+ declared: <code class="code">typedef msm::back::state_machine&lt;my_front_end&gt;
+ my_fsm;</code>
+ </p><p>We now have a fully functional state machine type. The next sections will
+ describe what can be done with it.</p></div><div class="sect2" title="Starting a state machine"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3705"></a><span class="command"><strong><a name="backend-start"></a></strong></span>Starting a state machine</h3></div></div></div><p>The <code class="code">start</code> method starts the state machine, meaning it will
+ activate the initial state, which means in turn that the initial state's
+ entry behavior will be called. We need the start method because you do not
+ always want the entry behavior of the initial state to be called immediately
+ but only when your state machine is ready to process events. A good example
+ of this is when you use a state machine to write an algorithm and each loop
+ back to the initial state is an algorithm call. Each call to start will make
+ the algorithm run once. The <a class="link" href="examples/iPodSearch.cpp" target="_top">iPodSearch</a> example uses this possibility.</p></div><div class="sect2" title="Event dispatching"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3717"></a>Event dispatching</h3></div></div></div><p>The main reason to exist for a state machine is to dispatch events. For
+ MSM, events are objects of a given event type. The object itself can contain
+ data, but the event type is what decides of the transition to be taken. For
+ MSM, if some_event is a given type (a simple struct for example) and e1 and
+ e2 concrete instances of some_event, e1 and e2 are equivalent, from a
+ transition perspective. Of course, e1 and e2 can have different values and
+ you can use them inside actions. Events are dispatched as const reference,
+ so actions cannot modify events for obvious side-effect reasons. To dispatch
+ an event of type some_event, you can simply create one on the fly or
+ instantiate if before processing: </p><p><code class="code">my_fsm fsm; fsm.process_event(some_event());</code></p><p><code class="code">some_event e1; fsm.process_event(e1)</code></p><p>Creating an event on the fly will be optimized by the compiler so the
+ performance will not degrade.</p></div><div class="sect2" title="Active state(s)"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3730"></a>Active state(s)</h3></div></div></div><p>The backend also offers a way to know which state is active, though you
+ will normally only need this for debugging purposes. If what you need simply
+ is doing something with the active state, <span class="command"><strong><a class="command" href="ch02s02.html#UML-internal-transition">internal transitions</a></strong></span> or
+ <span class="command"><strong><a class="command" href="ch03s05.html#backend-visitor">visitors</a></strong></span> are a better
+ alternative. If you need to know what state is active, const int*
+ current_state() will return an array of state ids. Please refer to the
+ <span class="command"><strong><a class="command" href="ch06s03.html#internals-state-id">internals section</a></strong></span> to
+ know how state ids are generated.</p></div><div class="sect2" title="Base state type"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3744"></a><span class="command"><strong><a name="backend-base-state"></a></strong></span>Base state type </h3></div></div></div><p>Sometimes, one needs to customize states to avoid repetition and provide a
+ common functionality, for example in the form of a virtual method. You might
+ also want to make your states polymorphic so that you can call typeid on
+ them for logging or debugging. It is also useful if you need a visitor, like
+ the next section will show. You will notice that all front-ends offer the
+ possibility of adding a base type. Note that all states and state machines
+ must have the same base state, so this could reduce reuse. For example,
+ using the basic front end, you need to:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Add the non-default base state in your msm::front::state&lt;&gt;
+ definition, as first template argument (except for
+ interrupt_states for which it is the second argument, the first
+ one being the event ending the interrupt), for example,
+ my_base_state being your new base state for all states in a
+ given state machine: <code class="code">struct Empty : public
+ msm::front::state&lt;my_base_state&gt;</code> Now,
+ my_base_state is your new base state. If it has a virtual
+ function, your states become polymorphic. MSM also provides a
+ default polymorphic base type,
+ <code class="code">msm::front::polymorphic_state</code>
+ </p></li><li class="listitem"><p>Add the user-defined base state in the state machine frontend
+ definition, as a second template argument, for example:
+ <code class="code">struct player_ : public
+ msm::front::state_machine&lt;player_,my_base_state&gt;
+ </code></p></li></ul></div><p>You can also ask for a state with a given id (which you might have gotten
+ from current_state()) using <code class="code">const base_state* get_state_by_id(int id)
+ const</code> where base_state is the one you just defined. You can now
+ do something polymorphically.</p></div><div class="sect2" title="Visitor"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3770"></a><span class="command"><strong><a name="backend-visitor"></a></strong></span>Visitor</h3></div></div></div><p>In some cases, having a pointer-to-base of the currently active states is
+ not enough. You might want to call non-virtually a method of the currently
+ active states. It will not be said that MSM forces the virtual keyword down
+ your throat!</p><p>To achieve this goal, MSM provides its own variation of a visitor pattern
+ using the previously described user-defined state technique. If you add to
+ your user-defined base state an <code class="code">accept_sig</code> typedef giving the
+ return value (unused for the moment) and parameters and provide an accept
+ method with this signature, calling visit_current_states will cause accept
+ to be called on the currently active states. Typically, you will also want
+ to provide an empty default accept in your base state in order in order not
+ to force all your states to implement accept. For example your base state
+ could be:</p><p><code class="code">struct my_visitable_state{</code></p><p><code class="code">// signature of the accept function</code></p><p><code class="code">typedef args&lt;void&gt; accept_sig;</code></p><p><code class="code">// we also want polymorphic states</code></p><p><code class="code">virtual ~my_visitable_state() {}</code></p><p><code class="code">// default implementation for states who do not need to be
+ visited</code></p><p><code class="code">void accept() const {}</code></p><p><code class="code">};</code></p><p>This makes your states polymorphic and visitable. In this case, accept is
+ made const and takes no argument. It could also be:</p><p><code class="code">struct SomeVisitor {&#8230;};</code></p><p><code class="code">struct my_visitable_state{</code></p><p><code class="code">// signature of the accept function</code></p><p><code class="code">typedef args&lt;void,SomeVisitor&amp;&gt; accept_sig;</code></p><p><code class="code">// we also want polymorphic states</code></p><p><code class="code">virtual ~my_visitable_state() {}</code></p><p><code class="code">// default implementation for states who do not need to be
+ visited</code></p><p><code class="code">void accept(SomeVisitor&amp;) const {}</code></p><p><code class="code">};</code></p><p>And now, <code class="code">accept</code> will take one argument (it could also be
+ non-const). By default, <code class="code">accept</code> takes up to 2 arguments. To get
+ more, set #define BOOST_MSM_VISITOR_ARG_SIZE to another value before
+ including state_machine.hpp. For example:</p><p><code class="code">#define BOOST_MSM_VISITOR_ARG_SIZE 3</code></p><p><code class="code">#include &lt;boost/msm/back/state_machine.hpp&gt;</code></p><p>Note that accept will be called on ALL active states <span class="underline">and also automatically on sub-states of a
+ submachine</span>.</p><p><span class="underline">Important warning</span>: The method
+ visit_current_states takes its parameter by value, so if the signature of
+ the accept function is to contain a parameter passed by reference, pass this
+ parameter with a boost:ref/cref to avoid undesired copies or slicing. So,
+ for example, in the above case, call:</p><p><code class="code">SomeVisitor vis; sm.visit_current_states(boost::ref(vis));
+ </code></p><p>This <a class="link" href="examples/SM-2Arg.cpp" target="_top">example</a> uses a
+ visiting function with 2 arguments.</p></div><div class="sect2" title="Flags"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3865"></a>Flags</h3></div></div></div><p>Flags is a MSM-only concept, supported by all front-ends, which base
+ themselves on the functions: </p><p><code class="code">template &lt;class Flag&gt; bool is_flag_active()</code> and</p><p><code class="code">template &lt;class Flag,class BinaryOp&gt; bool is_flag_active()</code>
+ </p><p>These functions return true if the currently active state(s) support the
+ Flag property. The first variant ORs the result if there are several
+ orthogonal regions, the second one expects OR or AND, for example:</p><p><code class="code">my_fsm.is_flag_active&lt;MyFlag&gt;()</code></p><p><code class="code">my_fsm.is_flag_active&lt;MyFlag,my_fsm_type::Flag_OR&gt;()</code></p><p>Please refer to the front-ends sections for usage examples.</p></div><div class="sect2" title="Getting a state"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3888"></a>Getting a state</h3></div></div></div><p>It is sometimes necessary to have the client code get access to the
+ states' data. After all, the states are created once for good and hang
+ around as long as the state machine does so why not use it? You simply just
+ need sometimes to get information about any state, even inactive ones. An
+ example is if you want to write a coverage tool and know how many times a
+ state was visited. To get a state, use the get_state method giving the state
+ name, for example: </p><p><code class="code">player::Stopped* tempstate =
+ p.get_state&lt;player::Stopped*&gt;();</code> or </p><p><code class="code">player::Stopped&amp; tempstate2 =
+ p.get_state&lt;player::Stopped&amp;&gt;();</code> depending on your
+ personal taste. </p></div><div class="sect2" title="State machine constructor with arguments"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3901"></a> State machine constructor with arguments </h3></div></div></div><p>You might want to define a state machine with a non-default constructor.
+ For example, you might want to write: </p><p><code class="code">struct player_ : public msm::front::state_machine_def&lt;player_&gt; {
+ player_(int some_value){&#8230;} } </code></p><p>This is possible, using the back-end as forwarding object: </p><p><code class="code">typedef msm::back::state_machine&lt;player_ &gt; player; player
+ p(3);</code> The back-end will call the corresponding front-end
+ constructor upon creation.</p><p>You can pass arguments up to the value of the
+ BOOST_MSM_CONSTRUCTOR_ARG_SIZE macro (currently 5) arguments. Change this
+ value before including any header if you need to overwrite the default.
+ </p></div><div class="sect2" title="Trading run-time speed for better compile-time / multi-TU compilation"><div class="titlepage"><div><div><h3 class="title"><a name="d0e3917"></a><span class="command"><strong><a name="backend-tradeof-rt-ct"></a></strong></span>Trading run-time speed for
+ better compile-time / multi-TU compilation</h3></div></div></div><p>MSM is optimized for run-time speed at the cost of longer compile-time.
+ This can become a problem with older compilers and big state machines,
+ especially if you don't really care about run-time speed that much and would
+ be satisfied by a performance roughly the same as most state machine
+ libraries. MSM offers a back-end policy to help there. But before you try
+ it, if you are using a VC compiler, deactivate the /Gm compiler option
+ (default for debug builds). This option can cause builds to be 3 times
+ longer... If the compile-time still is a problem, read further. MSM offers a
+ policy which will speed up compiling in two main cases:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>many transition conflicts</p></li><li class="listitem"><p>submachines</p></li></ul></div><p>The back-end <code class="code">msm::back::state_machine</code> has a third template
+ argument (first is the front-end, second is the history policy) defaulting
+ to <code class="code">favor_runtime_speed</code>. To switch to
+ <code class="code">favor_compile_time</code>, which is declared in
+ <code class="code">&lt;msm/back/favor_compile_time.hpp&gt;</code>, you need to:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>switch the policy to <code class="code">favor_compile_time</code> for the
+ main state machine (and possibly submachines)</p></li><li class="listitem"><p>move the submachine declarations into their own header which
+ includes
+ <code class="code">&lt;msm/back/favor_compile_time.hpp&gt;</code></p></li><li class="listitem"><p>add for each submachine a cpp file including your header and
+ calling a macro, which generates helper code, for
+ example:</p><p><code class="code">#include "mysubmachine.hpp"</code></p><p><code class="code">BOOST_MSM_BACK_GENERATE_PROCESS_EVENT(mysubmachine)</code></p></li><li class="listitem"><p>configure your compiler for multi-core compilation</p></li></ul></div><p>You will now compile your state machine on as many cores as you have
+ submachines, which will greatly speed up the compilation if you factor your
+ state machine into smaller submachines.</p><p>Independently, transition conflicts resolution will also be much
+ faster.</p><p>This policy uses boost.any behind the hood, which means that we will lose
+ one feature which MSM offers with the default policy, <a class="link" href="ch03s02.html#event-hierarchy">event hierarchy</a>. The following
+ example takes our iPod example and speeds up compile-time by using this
+ technique. We have:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><a class="link" href="examples/iPod_distributed/iPod.cpp" target="_top">our main
+ state machine and main function</a></p></li><li class="listitem"><p><a class="link" href="examples/iPod_distributed/PlayingMode.hpp" target="_top">PlayingMode moved to a separate header</a></p></li><li class="listitem"><p><a class="link" href="examples/iPod_distributed/PlayingMode.cpp" target="_top">a
+ cpp for PlayingMode</a></p></li><li class="listitem"><p><a class="link" href="examples/iPod_distributed/MenuMode.hpp" target="_top">MenuMode moved to a separate header</a></p></li><li class="listitem"><p><a class="link" href="examples/iPod_distributed/MenuMode.cpp" target="_top">a
+ cpp for MenuMode</a></p></li><li class="listitem"><p><a class="link" href="examples/iPod_distributed/Events.hpp" target="_top">events
+ move to a separate header as all machines use
+ it</a></p></li></ul></div><p>
+ </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">eUML (experimental)&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;4.&nbsp; Performance / Compilers</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch04.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch04.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,13 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;4.&nbsp; Performance / Compilers</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="prev" href="ch03s05.html" title="Back-end"><link rel="next" href="ch04s02.html" title="Executable size"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;4.&nbsp; Performance / Compilers</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s05.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;I.&nbsp;User' guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch04s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;4.&nbsp; Performan
ce / Compilers"><div class="titlepage"><div><div><h2 class="title"><a name="d0e4003"></a>Chapter&nbsp;4.&nbsp; Performance / Compilers</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1">Speed</span></dt><dt><span class="sect1">Executable size</span></dt><dt><span class="sect1">Supported compilers</span></dt><dt><span class="sect1"> Limitations </span></dt><dt><span class="sect1"> Compilers corner </span></dt></dl></div><p>Tests were made on different PCs running Windows XP and Vista and compiled with
+ VC9 SP1 or Ubuntu and compiled with g++ 4.2 and 4.3. For these tests, the same
+ player state machine was written using Boost.Statechart, as a <a class="link" href="examples/SC Simple.cpp" target="_top">state machine with only simple states</a>
+ and as a <a class="link" href="examples/SC Composite.cpp" target="_top">state machine with a composite
+ state</a>. The same simple and composite state machines are implemented with
+ MSM with a standard frontend <a class="link" href="examples/MsmSimple.cpp" target="_top">(simple)</a><a class="link" href="examples/MsmComposite.cpp" target="_top">(composite)</a>,
+ the simple one also with <a class="link" href="examples/MsmSimpleFunctors.cpp" target="_top">functors</a> and with <a class="link" href="examples/EumlSimple.cpp" target="_top">eUML</a>. As these simple machines need no terminate/interrupt states, no
+ message queue and have no-throw guarantee on their actions, the MSM state machines
+ are defined with minimum functionality. Test machine is a Q6600 2.4GHz, Vista
+ 64.</p><div class="sect1" title="Speed"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4025"></a>Speed</h2></div></div></div><p>VC9:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>The simple test completes 90 times faster with MSM than with
+ Boost.Statechart</p></li><li class="listitem"><p>The composite test completes 25 times faster with MSM</p></li></ul></div><p>gcc 4.2.3 (Ubuntu 8.04 in VMWare, same PC):</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>The simple test completes 46 times faster with MSM</p></li><li class="listitem"><p>The composite test completes 19 times faster with Msm</p></li></ul></div></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s05.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch04s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Back-end&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Executable size</td></tr></table></div>
</body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch04s02.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch04s02.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,14 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Executable size</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch04.html" title="Chapter&nbsp;4.&nbsp; Performance / Compilers"><link rel="prev" href="ch04.html" title="Chapter&nbsp;4.&nbsp; Performance / Compilers"><link rel="next" href="ch04s03.html" title="Supported compilers"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Executable size</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;4.&nbsp; Performance / Compilers</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch04s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Executable size"><div clas
s="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4046"></a>Executable size</h2></div></div></div><p>There are some worries that MSM generates huge code. Is it true? The 2
+ compilers I tested disagree with this claim. On VC9, the test state machines
+ used in the performance section produce executables of 14kB (for simple and
+ eUML) and 21kB (for the composite). This includes the test code and iostreams.
+ By comparison, an empty executable with iostreams generated by VC9 has a size of
+ 7kB. Boost.Statechart generates executables of 43kB and 54kB. As a bonus, eUML
+ comes for &#8220;free&#8221; in terms of executable size. You even get a speed gain. With
+ g++ 4.3, it strongly depends on the compiler options (much more than VC). A good
+ size state machine with &#8211;O3 can generate an executable of 600kB, and with eUML
+ you can get to 1.5MB. Trying with &#8211;Os &#8211;s I come down to 18kB and 30kB for the
+ test state machines, while eUML will go down to 1MB (which is still big), so in
+ this case eUML does not come for free.</p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch04.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch04s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;4.&nbsp; Performance / Compilers&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Supported compilers</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch04s03.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch04s03.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,9 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Supported compilers</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch04.html" title="Chapter&nbsp;4.&nbsp; Performance / Compilers"><link rel="prev" href="ch04s02.html" title="Executable size"><link rel="next" href="ch04s04.html" title="Limitations"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Supported compilers</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch04s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;4.&nbsp; Performance / Compilers</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch04s04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Supported compilers"><div class="titlepage"><div><
div><h2 class="title" style="clear: both"><a name="d0e4051"></a>Supported compilers</h2></div></div></div><p> MSM was successfully tested with: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>VC8 (please read further), VC9SP1, VC10 Beta 1 and 2</p></li><li class="listitem"><p>g++ 4.1 and higher</p></li><li class="listitem"><p>Green Hills Software MULTI for ARM v5.0.5 patch 4416 (Simple and
+ Composite tutorials)</p></li></ul></div><p> eUML will only work with: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>VC8 (partly). You cannot, however use any overloaded function
+ (like splice) and compile times and RAM consumption explode</p></li><li class="listitem"><p>VC9SP1, VC10 Beta1-2</p></li><li class="listitem"><p>g++ 4.3 and higher (previous versions lack native typeof
+ support)</p></li></ul></div><p>VC8 and to some lesser extent VC9 suffer from a bug. Enabling the option
+ "Enable Minimal Rebuild" (/Gm) will cause much higher compile-time (up to three
+ times with VC8!). This option being activated per default in Debug mode, this
+ can be a big problem.</p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch04s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch04.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch04s04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Executable size&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp; Limitations </td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch04s04.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch04s04.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,15 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Limitations</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch04.html" title="Chapter&nbsp;4.&nbsp; Performance / Compilers"><link rel="prev" href="ch04s03.html" title="Supported compilers"><link rel="next" href="ch04s05.html" title="Compilers corner"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center"> Limitations </th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch04s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;4.&nbsp; Performance / Compilers</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch04s05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Limitations"><div class="titlepage"><div><div><h2 class
="title" style="clear: both"><a name="d0e4080"></a> Limitations </h2></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Compilation times of state machines with &gt; 80 transitions that are
+ going to make you storm the CFO's office and make sure you get a
+ shiny octocore with 12GB RAM by next week, unless he's interested in
+ paying you watch the compiler agonize for hours... (Make sure you
+ ask for dual 24" as well, it doesn't hurt).</p></li><li class="listitem"><p>eUML allows very long constructs but will also quickly increase
+ your compile time on some compilers (VC9, VC10 Beta1) with buggy
+ decltype support (I suspect some at least quadratic algorithms
+ there). Even g++ 4.4 shows some regression compared to 4.3 and will
+ crash if the constructs become too big.</p></li><li class="listitem"><p>Need to overwrite the mpl::vector/list default-size-limit of 20
+ and fusion default vector size of 10 if more than 10 states found in
+ a state machine</p></li></ul></div><p>
+ </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch04s03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch04.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch04s05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Supported compilers&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp; Compilers corner </td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch04s05.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch04s05.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,30 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Compilers corner</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch04.html" title="Chapter&nbsp;4.&nbsp; Performance / Compilers"><link rel="prev" href="ch04s04.html" title="Limitations"><link rel="next" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Questions &amp; Answers"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center"> Compilers corner </th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch04s04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;4.&nbsp; Performance / Compilers</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Compilers corner"><div class="t
itlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4096"></a> Compilers corner </h2></div></div></div><p>Compilers are sometimes full of surprises and such strange errors happened in
+ the course of the development that I wanted to list the most fun for readers&#8217;
+ entertainment.</p><p><span class="underline">VC8</span>: </p><p><code class="code">template &lt;class StateType&gt; </code></p><p><code class="code">typename ::boost::enable_if&lt; </code></p><p><code class="code">typename ::boost::mpl::and_&lt;</code></p><p><code class="code">typename ::boost::mpl::not_&lt;typename
+ has_exit_pseudo_states&lt;StateType&gt;::type&gt;::type, </code></p><p><code class="code">typename ::boost::mpl::not_&lt;typename
+ is_pseudo_exit&lt;StateType&gt;::type&gt;::type &gt;::type,BaseState*&gt;::type
+ </code></p><p>I get the following error:</p><p>error C2770: invalid explicit template argument(s) for '`global
+ namespace'::boost::enable_if&lt;is_pseudo_exit&lt;StateType&gt;::type,BaseState*&gt;::type
+ boost::msm::state_machine&lt;Derived,HistoryPolicy,BaseState&gt;::add_state&lt;ContainingSM&gt;::new_state_helper(boost::msm::dummy&lt;__formal&gt;)
+ const' </p><p>If I now remove the first &#8220;::&#8221; in ::boost::mpl , the compiler shuts up. So in
+ this case, it is not possible to follow Boost&#8217;s guidelines.</p><p><span class="underline">VC9</span>:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>This one is my all times&#8217; favorite. Do you know why the exit
+ pseudo states are referenced in the transition table with a
+ &#8220;submachine::exit_pt&#8221; ? Because &#8220;exit&#8221; will crash the compiler.
+ &#8220;Exit&#8221; is not possible either because it will crash the compiler on
+ one machine, but not on another (the compiler was installed from the
+ same disk).</p></li><li class="listitem"><p>Sometimes, removing a policy crashes the compiler, so some
+ versions are defining a dummy policy called WorkaroundVC9.</p></li><li class="listitem"><p>Typeof: While g++ and VC9 compile &#8220;standard&#8221; state machines in
+ comparable times, Typeof (while in both ways natively supported)
+ seems to behave in a quadratic complexity with VC9 and VC10.</p></li><li class="listitem"><p>eUML: in case of a compiler crash, changing the order of state
+ definitions (first states without entry or exit) sometimes solves
+ the problem.</p></li></ul></div><p><span class="underline">g++ 4.x</span>: Boring compiler, almost all is
+ working almost as expected. Being not a language lawyer I am unsure about the
+ following &#8220;Typeof problem&#8221;. VC9 and g++ disagree on the question if you can
+ derive from the BOOST_TYPEOF generated type without first defining a typedef. I
+ will be thankful for an answer on this. I only found two ways to break the compiler:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Add more eUML constructs until something explodes (especially with
+ g++-4.4) </p></li><li class="listitem"><p>The build_terminate function uses 2 mpl::push_back instead of
+ mpl::insert_range because g++ would not accept insert_range.</p></li></ul></div><p>You can test your compiler&#8217;s decltype implementation with the <a class="link" href="examples/CompilerStressTestEuml.cpp" target="_top">following stress
+ test</a> and reactivate the commented-out code until the compiler
+ crashes.</p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch04s04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch04.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top"> Limitations &nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;5.&nbsp;Questions &amp; Answers</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch05.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch05.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,31 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;5.&nbsp;Questions &amp; Answers</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="prev" href="ch04s05.html" title="Compilers corner"><link rel="next" href="ch06.html" title="Chapter&nbsp;6.&nbsp;Internals"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;5.&nbsp;Questions &amp; Answers</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch04s05.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;I.&nbsp;User' guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch06.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;5.&
nbsp;Questions &amp; Answers"><div class="titlepage"><div><div><h2 class="title"><a name="d0e4159"></a>Chapter&nbsp;5.&nbsp;Questions &amp; Answers</h2></div></div></div><p><span class="underline">Question</span>: on_entry gets as argument, the
+ sent event. What event do I get when the state becomes default-activated (because it
+ is an initial state)?</p><p>
+ <span class="underline">Answer</span>: To allow you to know that the state
+ was default-activated, MSM generates a boost::msm::InitEvent default event. </p><p><span class="underline">Question</span>: Why do I see no call to
+ no_transition in my submachine? </p><p><span class="underline">Answer</span>: Because of the priority rule defined
+ by UML. It says that in case of transition conflict, the most inner state has a
+ higher priority. So after asking the inner state, the containing composite has to be
+ also asked to handle the transition and could find a possible transition.</p><p><span class="underline">Question</span>: Why do I get a compile error
+ saying the compiler cannot convert to a function ...Fsm::*(some_event)? </p><p><span class="underline">Answer</span>: You probably defined a transition
+ triggered by the event some_event, but used a guard/action method taking another
+ event. </p><p><span class="underline">Question</span>: Why do I get a compile error
+ saying something like &#8220;too few&#8221; or &#8220;too many&#8221; template arguments? </p><p><span class="underline">Answer</span>: You probably defined a transition in
+ form of a a_row or g_row where you wanted just a _row or the other way around. With
+ Row, it could mean that you forgot a "none". </p><p><span class="underline">Question</span>: Why do I get a very long compile
+ error when I define more than 20 rows in the transition table? </p><p><span class="underline">Answer</span>: MSM uses Boost.MPL under the hood
+ and this is the default maximum size. Please define the following 3 macros before
+ including any MSM headers: </p><p><code class="code">#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS </code></p><p><code class="code">#define BOOST_MPL_LIMIT_VECTOR_SIZE 30 // or whatever you need
+ </code></p><p><code class="code">#define BOOST_MPL_LIMIT_MAP_SIZE 30 // or whatever you need </code></p><p><span class="underline">Question</span>: Why do I get this error: &#8221;error
+ C2977: 'boost::mpl::vector' : too many template arguments&#8221;? </p><p><span class="underline">Answer</span>: The first possibility is that you
+ defined a transition table as, say, vector17 and have 18 entries. The second is that
+ you have 17 entries and have a composite state. Under the hood, MSM adds a row for
+ every event in the composite transition table. The third one is that you used a
+ mpl::vector without the number of entries but are close to the MPL default of 50 and
+ have a composite, thus pushing you above 50. Then you need mpl/vector60/70&#8230;.hpp and
+ a mpl/map60/70&#8230;.hpp </p><p><span class="underline">Question</span>: Why do I get a very long compile
+ error when I define more than 10 states in a state machine? </p><p><span class="underline">Answer</span>: MSM uses Boost.Fusion under the hood
+ and this is the default maximum size. Please define the following macro before
+ including any MSM headers: </p><p><code class="code">#define FUSION_MAX_VECTOR_SIZE 20 // or whatever you need </code></p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch04s05.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch06.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top"> Compilers corner &nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;6.&nbsp;Internals</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch06.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch06.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,61 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;6.&nbsp;Internals</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="prev" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Questions &amp; Answers"><link rel="next" href="ch06s02.html" title="Frontend / Backend interface"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;6.&nbsp;Internals</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;I.&nbsp;User' guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch06s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;6.&nb
sp;Internals"><div class="titlepage"><div><div><h2 class="title"><a name="d0e4231"></a>Chapter&nbsp;6.&nbsp;Internals</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1">Backend: Run To Completion</span></dt><dt><span class="sect1"><a href="ch06s02.html">Frontend / Backend
+ interface</a></span></dt><dt><span class="sect1"> Generated state ids </span></dt><dt><span class="sect1">Metaprogramming tools</span></dt></dl></div><p>This chapter describes the internal machinery of the back-end, which can be useful
+ for UML experts but can be safely ignored for most users. For implementers, the
+ interface between front- and back- end is also described in detail.</p><div class="sect1" title="Backend: Run To Completion"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4236"></a><span class="command"><strong><a name="run-to-completion"></a></strong></span>Backend: Run To Completion</h2></div></div></div><p>The back-end implements the following run-to completion algorithm:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Check if one region of the concrete state machine is in a
+ terminate or interrupt state. If yes, event processing is disabled
+ while the condition lasts (forever for a terminate pseudo-state,
+ while active for an interrupt pseudo-state).</p></li><li class="listitem"><p>If the message queue feature is enabled and if the state machine
+ is already processing an event, push the currently processed event
+ into the queue and end processing. Otherwise, remember that the
+ state machine is now processing an event and continue.</p></li><li class="listitem"><p>If the state machine detected that no deferred event is used, skip
+ this step. Otherwise, mark the first deferred event from the
+ deferred queue as active.</p></li><li class="listitem"><p>Now start the core of event dispatching. If exception handling is
+ activated, this will happen inside a try/catch block and the
+ front-end <code class="code">exception_caught</code> is called if an exception
+ occurs. </p></li><li class="listitem"><p>The event is now dispatched in turn to every region, in the order
+ defined by the initial state front-end definition. This will, for
+ every region, call the corresponding front-end transition definition
+ (the "row" or "Row" of the transition table).</p></li><li class="listitem"><p>Without transition conflict, if for a given region a transition is
+ possible, the guard condition is checked. If it returns
+ <code class="code">true</code>, the transition processing continues and the
+ current state's exit action is called, followed by the transition
+ action behavior and the new active state's entry behavior.</p></li><li class="listitem"><p>With transition conflicts (several possible transitions,
+ disambiguated by mutually exclusive guard conditions), the guard
+ conditions are tried in reverse order of their transition definition
+ in the transition table. The first one returning <code class="code">true</code>
+ selects its transition. Note that this is not defined by the UML
+ standard, which simply specifies that if the guard conditions are
+ not mutually exclusive, the state machine is ill-formed and the
+ behaviour undefined. Relying on this implementation-specific
+ behaviour will make it harder for the developer to support another
+ state machine framework.</p></li><li class="listitem"><p>If at least one region processes the event, this event is seen as
+ having been accepted. If not, the library calls
+ <code class="code">no_transition</code> on the state machine for every
+ contained region.</p></li><li class="listitem"><p>If the currently active state is a submachine, the behaviour is
+ slightly different. The UML standard specifies that internal
+ transitions have to be tried first, so the event is first dispatched
+ to the submachine. Only if the submachine does not accept the event
+ are other (non internal) transitions tried.</p></li><li class="listitem"><p>This back-end supports simple states' and submachines' internal
+ transitions. These are provided in the state's
+ <code class="code">internal_transition_table</code> type. Transitions defined
+ in this table are added at the end of the main state machine's
+ transition table, but with a lesser priority than the submachine's
+ transitions (defined in <code class="code">transition_table</code>). This means,
+ for simple states, that these transitions have higher priority than
+ non-internal transitions, conform to the UML standard which gives
+ higher priority to deeper-level transitions. For submachines, this
+ is a non-standard addition which can help make event processing
+ faster by giving a chance to bypass subregion processing. With
+ standard UML, one would need to add a subregion only to process
+ these internal transitions, which would be slower.</p></li><li class="listitem"><p>After the dispatching itself, the deferred event marked in step 3
+ (if any) now gets a chance of processing.</p></li><li class="listitem"><p>Then, events queued in the message queue also get a dispatching
+ chance</p></li><li class="listitem"><p>Finally, completion / anonymous transitions, if to be found in the
+ transition table, also get their dispatching chance.</p></li></ul></div><p>This algorithm illustrates how the back-end configures itself at compile-time
+ as much as possible. Every feature not found in a given state machine definition
+ is deactivated and has therefore no runtime cost. Completion events, deferred
+ events, terminate states, dispatching to several regions, internal transitions
+ are all deactivated if not used. User configuration is only for exception
+ handling and message queue necessary.</p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch06s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;5.&nbsp;Questions &amp; Answers&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Frontend / Backend
+ interface</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch06s02.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch06s02.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,60 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Frontend / Backend interface</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch06.html" title="Chapter&nbsp;6.&nbsp;Internals"><link rel="prev" href="ch06.html" title="Chapter&nbsp;6.&nbsp;Internals"><link rel="next" href="ch06s03.html" title="Generated state ids"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Frontend / Backend
+ interface</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch06.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;6.&nbsp;Internals</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch06s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Frontend / Backend interface"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4302"></a><span class="command"><strong><a name="internals-front-back-interface"></a></strong></span>Frontend / Backend
+ interface</h2></div></div></div><p>The design of MSM tries to make front-ends and back-ends (later) to be as
+ interchangeable as possible. Of course, no back-end will ever implement every
+ feature defined by any possible front-end and inversely, but the goal is to make
+ it as easy as possible to extend the current state of the library.</p><p>To achieve this, MSM divides the functionality between both sides: the
+ front-end is a sort of user interface and is descriptive, the back-end
+ implements the state machine engine.</p><p>MSM being based on a transition table, a concrete state machine (or a given
+ front-end) must provide a transition_table. This transition table must be made
+ of rows. And each row must tell what kind of transition it is and implement the
+ calls to the actions and guards. A state machine must also define its regions
+ (marked by initial states) And that is about the only constraints for
+ front-ends. How the rows are described is implementer's choice. </p><p>Every row must provide:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>A <code class="code">Source</code> typedef indicating, well, the type of the source
+ state.</p></li><li class="listitem"><p>A <code class="code">Target</code> typedef indicating, well, the type of the target
+ state.</p></li><li class="listitem"><p>A <code class="code">Evt</code> typedef indicating the type of the event triggering
+ the transition.</p></li><li class="listitem"><p>A <code class="code">row_type_tag</code> typedef indicating the type of the
+ transition.</p></li><li class="listitem"><p>Rows having a type requiring transition actions must provide a static
+ function <code class="code">action_call</code> with the following signature: <code class="code">
+ template &lt;class Fsm,class SourceState,class TargetState,class
+ AllStates&gt; </code></p><p><code class="code">static void action_call (Fsm&amp; fsm, Event const&amp; evt,
+ SourceState&amp;, TargetState&amp;, AllStates&amp;) </code></p><p>The function gets as parameters the (back-end) state machine, the
+ event, source and target states and a container (in the current
+ back-end, a fusion::set) of all the states defined in the state machine.
+ For example, as the back-end has the front-end as basic class,
+ <code class="code">action_call</code> is simply defined as
+ <code class="code">(fsm.*action)(evt)</code>.</p></li><li class="listitem"><p>Rows having a type requiring a guard must provide a static function
+ <code class="code">guard_call</code> with the following signature:<code class="code"> </code></p><p><code class="code">template &lt;class Fsm,class SourceState,class TargetState,class
+ AllStates&gt;</code></p><p><code class="code">static bool guard_call (Fsm&amp;, Event const&amp;,
+ SourceState&amp;, TargetState&amp;, AllStates&amp;)</code></p></li><li class="listitem"><p>The possible transition (row) types are:</p><div class="itemizedlist"><ul class="itemizedlist" type="circle"><li class="listitem"><p>a_row_tag: a transition with actions and no guard</p></li><li class="listitem"><p>g_row_type: a transition with a guard and no
+ actions</p></li><li class="listitem"><p>_row_tag: a transition without actions or guard</p></li><li class="listitem"><p>row_tag: a transition with guard and actions</p></li><li class="listitem"><p>a_irow_tag: an internal transition (defined inside the
+ <code class="code">transition_table</code>) with actions</p></li><li class="listitem"><p>g_irow_tag: an internal transition (defined inside the
+ <code class="code">transition_table</code>) with guard</p></li><li class="listitem"><p>irow_tag: an internal transition (defined inside the
+ <code class="code">transition_table</code>) with actions and
+ guards</p></li><li class="listitem"><p>_irow_tag: an internal transition (defined inside the
+ <code class="code">transition_table</code>) without action or guard.
+ Due to higher priority for internal transitions, this is
+ equivalent to a "ignore event"</p></li><li class="listitem"><p>sm_a_i_row_tag: an internal transition (defined inside the
+ <code class="code">internal_transition_table</code>) with
+ actions</p></li><li class="listitem"><p>sm_g_i_row_tag: an internal transition (defined inside the
+ <code class="code">internal_transition_table</code>) with
+ guard</p></li><li class="listitem"><p>sm_i_row_tag: an internal transition (defined inside the
+ <code class="code">internal_transition_table</code>) with actions and
+ guards</p></li><li class="listitem"><p>sm__i_row_tag: an internal transition (defined inside the
+ <code class="code">internal_transition_table</code>) without action
+ or guard. Due to higher priority for internal transitions,
+ this is quivalent to a "ignore event"</p></li></ul></div></li></ul></div><p>Furthermore, a front-end must provide the definition of states and state
+ machines. State machine definitions must provide (the implementer is free to
+ provide it or let it be done by every concrete state machine. Different MSM
+ front-ends took one or the other approach):</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">initial_state</code>: This typedef can be a single state or
+ a mpl container and provides the initial states defining one or
+ several orthogonal regions.</p></li><li class="listitem"><p><code class="code">transition_table</code>: This typedef is a MPL sequence of
+ transition rows.</p></li><li class="listitem"><p><code class="code">configuration</code>: this typedef is a MPL sequence of
+ known types triggering special behavior in the back-end, for example
+ if a concrete fsm requires a message queue or exception
+ catching.</p></li></ul></div><p>States and state machines must both provide a (possibly empty) definition of:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p><code class="code">flag_list</code>: the flags being active when this state or
+ state machine become the current state of the fsm.</p></li><li class="listitem"><p><code class="code">deferred_events</code>: events being automatically deferred
+ when the state is the current state of the fsm.</p></li><li class="listitem"><p><code class="code">internal_transition_table</code>: the internal transitions
+ of this state.</p></li><li class="listitem"><p><code class="code">on_entry</code> and <code class="code">on_exit</code> methods.</p></li></ul></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch06.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch06.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch06s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;6.&nbsp;Internals&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp; Generated state ids </td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch06s03.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch06s03.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,23 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Generated state ids</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch06.html" title="Chapter&nbsp;6.&nbsp;Internals"><link rel="prev" href="ch06s02.html" title="Frontend / Backend interface"><link rel="next" href="ch06s04.html" title="Metaprogramming tools"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center"> Generated state ids </th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch06s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;6.&nbsp;Internals</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch06s04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Generated state ids"><div class="titlepage"><div><div><
h2 class="title" style="clear: both"><a name="d0e4480"></a><span class="command"><strong><a name="internals-state-id"></a></strong></span> Generated state ids </h2></div></div></div><p>Normally, one does not need to know the ids are generated for all the states
+ of a state machine, unless for debugging purposes, like the pstate function does
+ in the tutorials in order to display the name of the current state. This section
+ will show how to automatically display typeid-generated names, but these are not
+ very readable on all platforms, so it can help to know how the ids are
+ generated. The ids are generated using the transition table, from the &#8220;Start&#8221;
+ column up to down, then from the &#8220;Next&#8221; column, up to down, as shown in the next
+ image: </p><p><span class="inlinemediaobject"><img src="../images/AnnexA.jpg" width="90%"></span></p><p>Stopped will get id 0, Open id 1, ErrorMode id 6 and SleepMode (seen only in
+ the &#8220;Next&#8221; column) id 7. If you have some implicitly created states, like
+ transition-less initial states or states created using the explicit_creation
+ typedef, these will be added as a source at the end of the transition table. If
+ you have submachine states, a row will be added for them at the end of the
+ table, after the automatically or explicitly created states, which can change
+ their id. The next help you will need for debugging would be to call the
+ current_state method of the state_machine class, then the display_type helper to
+ generate a readable name from the id. If you do not want to go through the
+ transition table to fill an array of names, the library provides another helper,
+ fill_state_names, which, given an array of sufficient size (please see next
+ section to know how many states are defined in the state machine), will fill it
+ with typeid-generated names. </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch06s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch06.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch06s04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Frontend / Backend
+ interface&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Metaprogramming tools</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch06s04.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch06s04.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,26 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Metaprogramming tools</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch06.html" title="Chapter&nbsp;6.&nbsp;Internals"><link rel="prev" href="ch06s03.html" title="Generated state ids"><link rel="next" href="ch07.html" title="Chapter&nbsp;7.&nbsp;Acknowledgements"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Metaprogramming tools</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch06s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;6.&nbsp;Internals</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch07.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Metaprogramming tools"><div class="titlepage"><div><
div><h2 class="title" style="clear: both"><a name="d0e4492"></a>Metaprogramming tools</h2></div></div></div><p>We can find for the transition table more uses than what we have seen so far.
+ Let's suppose you need to write a coverage tool. A state machine would be
+ perfect for such a job, if only it could provide some information about its
+ structure. Thanks to the transition table and Boost.MPL, it does.</p><p>What is needed for a coverage tool? You need to know how many states are
+ defined in the state machine, and how many events can be fired. This way you can
+ log the fired events and the states visited in the life of a concrete machine
+ and be able to perform some coverage analysis, like &#8220;fired 65% of all possible
+ events and visited 80% of the states defined in the state machine&#8221;. To achieve
+ this, MSM provides a few useful tools:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>generate_state_set&lt;transition table&gt;: returns a mpl::set of all
+ the states defined in the table.</p></li><li class="listitem"><p>generate_event_set&lt;transition table&gt;: returns a mpl::set of all
+ the events defined in the table.</p></li><li class="listitem"><p>using mpl::size&lt;&gt;::value you can get the number of elements in
+ the set.</p></li><li class="listitem"><p>display_type defines an operator() sending typeid(Type).name() to
+ cout.</p></li><li class="listitem"><p>fill_state_names fills an array of char const* with names of all
+ states (found by typeid)</p></li><li class="listitem"><p>using mpl::for_each on the result of generate_state_set and
+ generate_event_set passing display_type as argument will display all
+ the states of the state machine.</p></li><li class="listitem"><p>let's suppose you need to recursively find the states and events
+ defined in the composite states and thus also having a transition
+ table. Calling recursive_get_transition_table&lt;Composite&gt; will
+ return you the transition table of the composite state, recursively
+ adding the transition tables of all sub-state machines and
+ sub-sub...-sub-state machines. Then call generate_state_set or
+ generate_event_set on the result to get the full list of states and
+ events. </p></li></ul></div><p> An <a class="link" href="examples/BoostCon09Full.cpp" target="_top">example</a> shows the
+ tools in action. </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch06s03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch06.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch07.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top"> Generated state ids &nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;7.&nbsp;Acknowledgements</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch07.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch07.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,13 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;7.&nbsp;Acknowledgements</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="prev" href="ch06s04.html" title="Metaprogramming tools"><link rel="next" href="ch07s02.html" title="MSM v1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;7.&nbsp;Acknowledgements</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch06s04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;I.&nbsp;User' guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch07s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;7.&nbsp;Acknowledgements"><div
 class="titlepage"><div><div><h2 class="title"><a name="d0e4526"></a>Chapter&nbsp;7.&nbsp;Acknowledgements</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1">MSM v2</span></dt><dt><span class="sect1"> MSM v1</span></dt></dl></div><p>I am in debt to the following people who helped MSM along the way.</p><div class="sect1" title="MSM v2"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4531"></a>MSM v2</h2></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Thanks to Dave Abrahams for managing the review</p></li><li class="listitem"><p>Thanks to Eric Niebler for his patience correcting my grammar
+ errors</p></li><li class="listitem"><p>Special thanks to Joel de Guzman who gave me very good ideas at
+ the BoostCon09. These ideas were the starting point of the redesign.
+ Any time again, Joel &#9786;</p></li><li class="listitem"><p>Thanks to Richard O&#8217;Hara for making Green Hills bring a patch in
+ less than 1 week, thus adding one more compiler to the supported
+ list.</p></li><li class="listitem"><p>Big thanks to those who took the time to write a review: Franz
+ Alt, David Bergman, Michael Caisse, Barend Gehrels, Darryl Greene,
+ Juraj Ivancic, Erik Nelson, Kenny Riddile.</p></li><li class="listitem"><p>Thanks to Matt Calabrese, Juraj Ivancic and Joseph Wu for
+ reporting bugs.</p></li></ul></div><p>
+ </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch06s04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch07s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Metaprogramming tools&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp; MSM v1</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch07s02.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch07s02.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,13 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>MSM v1</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="ch07.html" title="Chapter&nbsp;7.&nbsp;Acknowledgements"><link rel="prev" href="ch07.html" title="Chapter&nbsp;7.&nbsp;Acknowledgements"><link rel="next" href="ch08.html" title="Chapter&nbsp;8.&nbsp;Version history"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center"> MSM v1</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch07.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;7.&nbsp;Acknowledgements</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch08.html">Next</a></td></tr></table><hr></div><div class="sect1" title="MSM v1"><div class="titlepage"><div><div><h2 class="titl
e" style="clear: both"><a name="d0e4556"></a> MSM v1</h2></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>The original version of this framework is based on the brilliant
+ work of David Abrahams and Aleksey Gurtovoy who laid down the base
+ and the principles of the framework in their excellent book, &#8220;C++
+ template Metaprogramming&#8221;. The implementation also makes heavy use
+ of the boost::mpl.</p></li><li class="listitem"><p>Thanks to Jeff Flinn for his idea of the user-defined base state
+ and his review which allowed MSM to be presented at the
+ BoostCon09.</p></li><li class="listitem"><p>Thanks to my MSM v1 beta testers, Christoph Woskowski and Franz
+ Alt for using the framework with little documentation and to my
+ private reviewer, Edouard Alligand</p></li></ul></div><p>
+ </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch07.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch07.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch08.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;7.&nbsp;Acknowledgements&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;8.&nbsp;Version history</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch08.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch08.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,8 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;8.&nbsp;Version history</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt01.html" title="Part&nbsp;I.&nbsp;User' guide"><link rel="prev" href="ch07s02.html" title="MSM v1"><link rel="next" href="pt02.html" title="Part&nbsp;II.&nbsp;Reference"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;8.&nbsp;Version history</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch07s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;I.&nbsp;User' guide</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="pt02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;8.&nbsp;Version history"><div c
lass="titlepage"><div><div><h2 class="title"><a name="d0e4572"></a>Chapter&nbsp;8.&nbsp;Version history</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1">From V2.0 to V2.10</span></dt></dl></div><div class="sect1" title="From V2.0 to V2.10"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4575"></a>From V2.0 to V2.10</h2></div></div></div><p>
+ </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>New documentation</p></li><li class="listitem"><p>Internal transitions. Either as part of the transition table or
+ using a state's internal transition table</p></li><li class="listitem"><p>increased dispatch and copy speed</p></li><li class="listitem"><p>new eUML syntax, better attribute support, macros to ease
+ developer's life. Even VC8 seems to like it better.</p></li><li class="listitem"><p>New policy for reduced compile-time at the cost of dispatch
+ speed</p></li><li class="listitem"><p>Support for base events</p></li><li class="listitem"><p>possibility to choose the initial event</p></li></ul></div><p>
+ </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch07s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="pt02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top"> MSM v1&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Part&nbsp;II.&nbsp;Reference</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch08s02.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch08s02.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,23 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>eUML functions</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="ch08.html" title="Chapter&nbsp;8.&nbsp;Reference"><link rel="prev" href="ch08.html" title="Chapter&nbsp;8.&nbsp;Reference"><link rel="next" href="ch08s03.html" title="Functional programming"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">eUML functions</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch08.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;8.&nbsp;Reference</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch08s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="eUML functions"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4306"></a>eUML functions</h2></div></
div></div><p>The following table lists the supported operators: </p><p>
+ </p><div class="table"><a name="d0e4313"></a><p class="title"><b>Table&nbsp;8.1.&nbsp;Operators and state machine helpers</b></p><div class="table-contents"><table summary="Operators and state machine helpers" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>eUML function / operator</th><th>Description</th><th>Functor</th></tr></thead><tbody><tr><td>&amp;&amp;</td><td>Calls lazily Action1&amp;&amp; Action2</td><td>And_</td></tr><tr><td>||</td><td>Calls lazily Action1|| Action2</td><td>Or_</td></tr><tr><td>!</td><td>Calls lazily !Action1</td><td>Not_</td></tr><tr><td>!=</td><td>Calls lazily Action1 != Action2</td><td>NotEqualTo_</td></tr><tr><td>==</td><td>Calls lazily Action1 == Action2</td><td>EqualTo_</td></tr><tr><td>&gt;</td><td>Calls lazily Action1 &gt; Action2</td><td>Greater_</td></tr><tr><td>&gt;=</td><td>Calls lazily Action1 &gt;= Action2</td><td>Greater_Equal_</td></tr><tr><td>&lt;</td><td>Calls lazily Action1 &lt; Action2</td><td>Less_</td></tr><tr><td>&lt;=</td><td>C
alls lazily Action1 &lt;= Action2</td><td>Less_Equal_</td></tr><tr><td>&amp;</td><td>Calls lazily Action1 &amp; Action2</td><td>Bitwise_And_</td></tr><tr><td>|</td><td>Calls lazily Action1 | Action2</td><td>Bitwise_Or_</td></tr><tr><td>^</td><td>Calls lazily Action1 ^ Action2</td><td>Bitwise_Xor_</td></tr><tr><td>--</td><td>Calls lazily --Action1 / Action1--</td><td>Pre_Dec_ / Post_Dec_</td></tr><tr><td>++</td><td>Calls lazily ++Action1 / Action1++</td><td>Pre_Inc_ / Post_Inc_</td></tr><tr><td>/</td><td>Calls lazily Action1 / Action2</td><td>Divides_</td></tr><tr><td>/=</td><td>Calls lazily Action1 /= Action2</td><td>Divides_Assign_</td></tr><tr><td>*</td><td>Calls lazily Action1 * Action2</td><td>Multiplies_</td></tr><tr><td>*=</td><td>Calls lazily Action1 *= Action2</td><td>Multiplies_Assign_</td></tr><tr><td>+ (binary)</td><td>Calls lazily Action1 + Action2</td><td>Plus_</td></tr><tr><td>+ (unary)</td><td>Calls lazily +Action1</td><td>Unary_Plus_</td></tr><tr><td>+=</td><td>Calls lazily Action1 += Action2
</td><td>Plus_Assign_</td></tr><tr><td>- (binary)</td><td>Calls lazily Action1 - Action2</td><td>Minus_</td></tr><tr><td>- (unary)</td><td>Calls lazily -Action1</td><td>Unary_Minus_</td></tr><tr><td>-=</td><td>Calls lazily Action1 -= Action2</td><td>Minus_Assign_</td></tr><tr><td>%</td><td>Calls lazily Action1 % Action2</td><td>Modulus_</td></tr><tr><td>%=</td><td>Calls lazily Action1 %= Action2</td><td>Modulus_Assign_</td></tr><tr><td>&gt;&gt;</td><td>Calls lazily Action1 &gt;&gt; Action2</td><td>ShiftRight_</td></tr><tr><td>&gt;&gt;=</td><td>Calls lazily Action1 &gt;&gt;= Action2</td><td>ShiftRight_Assign_</td></tr><tr><td>&lt;&lt;</td><td>Calls lazily Action1 &lt;&lt; Action2</td><td>ShiftLeft_</td></tr><tr><td>&lt;&lt;=</td><td>Calls lazily Action1 &lt;&lt;= Action2</td><td>ShiftLeft_Assign_</td></tr><tr><td>[] (works on vector, map, arrays)</td><td>Calls lazily Action1 [Action2]</td><td>Subscript_</td></tr><tr><td>if_then_else_(Condition,Action1,Action2)</td><td>Returns either the result of calling Acti
on1 or the result of
+ calling Action2</td><td>If_Else_</td></tr><tr><td>if_then_(Condition,Action)</td><td>Returns the result of calling Action if Condition</td><td>If_Then_</td></tr><tr><td>while_(Condition, Body)</td><td>While Condition(), calls Body(). Returns nothing</td><td>While_Do_</td></tr><tr><td>do_while_(Condition, Body)</td><td>Calls Body() while Condition(). Returns nothing</td><td>Do_While_</td></tr><tr><td>for_(Begin,Stop,EndLoop,Body)</td><td>Calls for(Begin;Stop;EndLoop){Body;}</td><td>For_Loop_</td></tr><tr><td>process_(Event [,fsm1] [,fsm2] [,fsm3] [,fsm4])</td><td>Processes Event on the current state machine (if no fsm
+ specified) or on up to 4 state machines returned by an
+ appropriate functor.</td><td>Process_</td></tr><tr><td>process2_(Event, Data [,fsm1] [,fsm2] [,fsm3])</td><td>Processes Event on the current state machine (if no fsm
+ specified) or on up to 2 state machines returned by an
+ appropriate functor. The event is copy-constructed from what
+ Data() returns.</td><td>Process2_</td></tr><tr><td>is_flag_(Flag [,fsm])</td><td>Calls is_flag_active() on the current state machine or the
+ one returned by calling fsm.</td><td>Get_Flag_</td></tr><tr><td>event_ [(attribute name)]</td><td>Returns the current event (as const reference)</td><td>GetEvent_</td></tr><tr><td>source_ [(attribute name)]</td><td>Returns the source state of the currently triggered
+ transition (as reference). If an attribute name is provided,
+ returns the attribute by reference.</td><td>GetSource_</td></tr><tr><td>target_ [(attribute name)]</td><td>Returns the target state of the currently triggered
+ transition (as reference). If an attribute name is provided,
+ returns the attribute by reference.</td><td>GetTarget_</td></tr><tr><td>state_ [(attribute name)]</td><td>Returns the source state of the currently active state (as
+ reference). Valid inside a state entry/exit action. If an
+ attribute name is provided, returns the attribute by
+ reference.</td><td>GetState_</td></tr><tr><td>fsm_ [(attribute name)]</td><td>Returns the current state machine (as reference). Valid
+ inside a state entry/exit action or a transition. If an
+ attribute name is provided, returns the attribute by
+ reference.</td><td>GetFsm_</td></tr><tr><td>substate_(state_name [,fsm])</td><td>Returns (as reference) the state state_name referenced in the
+ current state machine or the one given as argument.</td><td>SubState_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>TODO macro for functor def</p><p>To use these functions, you need to include: </p><p><code class="code">#include &lt;msm/front/euml/euml.hpp&gt;</code></p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch08.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch08.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch08s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;8.&nbsp;Reference&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp; Functional programming </td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch08s03.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch08s03.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,92 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Functional programming</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM)"><link rel="up" href="ch08.html" title="Chapter&nbsp;8.&nbsp;Reference"><link rel="prev" href="ch08s02.html" title="eUML functions"><link rel="next" href="rn01.html" title="Reference"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center"> Functional programming </th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch08s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;8.&nbsp;Reference</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="rn01.html">Next</a></td></tr></table><hr></div><div class="sect1" title="Functional programming"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="d0e4652"></a> Functional programming </h2><
/div></div></div><p>To use these functions, you need to include: </p><p><code class="code">#include &lt;msm/front/euml/stl.hpp&gt;</code></p><p>or the specified header in the following tables.</p><p>The following table lists the supported STL algorithms: </p><p>
+ </p><div class="table"><a name="d0e4666"></a><p class="title"><b>Table&nbsp;8.2.&nbsp;STL algorithms</b></p><div class="table-contents"><table summary="STL algorithms" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL algorithms in querying.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>find_(first, last, value)</td><td>Find_</td></tr><tr><td>find_if_(first, last, value)</td><td>FindIf_</td></tr><tr><td>lower_bound_(first, last, value [,op&#7491;])</td><td>LowerBound_</td></tr><tr><td>upper_bound_(first, last, value [,op&#7491;])</td><td>UpperBound_</td></tr><tr><td>equal_range_(first, last, value [,op&#7491;])</td><td>EqualRange_</td></tr><tr><td>binary_search_(first, last, value [,op&#7491;])</td><td>BinarySearch_</td></tr><tr><td>min_element_(first, last[,op&#7491;])</td><td>MinElement_</td></tr><tr><td>max_element_(first, last[,op&#7491;])</td><td>MaxElement_</td></tr><tr><td>adjacent_find_(first, last[,op&#7491;])</td><td>AdjacentFind_</td></tr><tr><td>find_end_( first1,
 last1, first2, last2 [,op &#7491;])</td><td>FindEnd_</td></tr><tr><td>find_first_of_( first1, last1, first2, last2 [,op &#7491;])</td><td>FindFirstOf_</td></tr><tr><td>equal_( first1, last1, first2 [,op &#7491;])</td><td>Equal_</td></tr><tr><td>search_( first1, last1, first2, last2 [,op &#7491;])</td><td>Search_</td></tr><tr><td>includes_( first1, last1, first2, last2 [,op &#7491;])</td><td>Includes_</td></tr><tr><td>lexicographical_compare_ ( first1, last1, first2, last2 [,op
+ &#7491;]) </td><td>LexicographicalCompare_</td></tr><tr><td>count_(first, last, value [,size])</td><td>Count_</td></tr><tr><td>count_if_(first, last, op &#7491; [,size])</td><td>CountIf_</td></tr><tr><td>distance_(first, last)</td><td>Distance_</td></tr><tr><td>mismatch _( first1, last1, first2 [,op &#7491;])</td><td>Mismatch_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e4777"></a><p class="title"><b>Table&nbsp;8.3.&nbsp;STL algorithms</b></p><div class="table-contents"><table summary="STL algorithms" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL algorithms in transformation.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>copy_(first, last, result)</td><td>Copy_</td></tr><tr><td>copy_backward_(first, last, result)</td><td>CopyBackward_</td></tr><tr><td>reverse_(first, last)</td><td>Reverse_</td></tr><tr><td>reverse_copy_(first, last , result)</td><td>ReverseCopy_</td></tr><tr><td>remove_(first, last, value)</td><td>Remove_</td></tr><tr><td>remove_if_(first, last , op&#7491;)</td><td>RemoveIf_</td></tr><tr><td>remove_copy_(first, last , output, value)</td><td>RemoveCopy_</td></tr><tr><td>remove_copy_if_(first, last, output, op&#7491;)</td><td>RemoveCopyIf_</td></tr><tr><td>fill_(first, last, value)</td><td>Fill_</td></tr><tr><td>fill_n_(first, size, value)&#7495;</td><td>FillN_</td></tr><tr><td>generate_(f
irst, last, generator&#7491;)</td><td>Generate_</td></tr><tr><td>generate_(first, size, generator&#7491;)&#7495;</td><td>GenerateN_</td></tr><tr><td>unique_(first, last [,op&#7491;])</td><td>Unique_</td></tr><tr><td>unique_copy_(first, last, output [,op&#7491;])</td><td>UniqueCopy_</td></tr><tr><td>random_shuffle_(first, last [,op&#7491;])</td><td>RandomShuffle_</td></tr><tr><td>rotate_copy_(first, middle, last, output)</td><td>RotateCopy_</td></tr><tr><td>partition_ (first, last [,op&#7491;])</td><td>Partition_</td></tr><tr><td>stable_partition_ (first, last [,op&#7491;])</td><td>StablePartition_</td></tr><tr><td>stable_sort_(first, last [,op&#7491;])</td><td>StableSort_</td></tr><tr><td>sort_(first, last [,op&#7491;])</td><td>Sort_</td></tr><tr><td>partial_sort_(first, middle, last [,op&#7491;])</td><td>PartialSort_</td></tr><tr><td>partial_sort_copy_ (first, last, res_first, res_last [,op&#7491;]) </td><td>PartialSortCopy_</td></tr><tr><td>nth_element_(first, nth, last [,op&#7491;])</td><td>NthElement_</t
d></tr><tr><td>merge_( first1, last1, first2, last2, output [,op &#7491;])</td><td>Merge_</td></tr><tr><td>inplace_merge_(first, middle, last [,op&#7491;])</td><td>InplaceMerge_</td></tr><tr><td>set_union_(first1, last1, first2, last2, output [,op
+ &#7491;])</td><td>SetUnion_</td></tr><tr><td>push_heap_(first, last [,op &#7491;])</td><td>PushHeap_</td></tr><tr><td>pop_heap_(first, last [,op &#7491;])</td><td>PopHeap_</td></tr><tr><td>make_heap_(first, last [,op &#7491;])</td><td>MakeHeap_</td></tr><tr><td>sort_heap_(first, last [,op &#7491;])</td><td>SortHeap_</td></tr><tr><td>next_permutation_(first, last [,op &#7491;])</td><td>NextPermutation_</td></tr><tr><td>prev_permutation_(first, last [,op &#7491;])</td><td>PrevPermutation_</td></tr><tr><td>inner_product_(first1, last1, first2, init [,op1&#7491;] [,op2&#7491;]) </td><td>InnerProduct_</td></tr><tr><td>partial_sum_(first, last, output [,op&#7491;])</td><td>PartialSum_</td></tr><tr><td>adjacent_difference_(first, last, output [,op&#7491;])</td><td>AdjacentDifference_</td></tr><tr><td>replace_(first, last, old_value, new_value)</td><td>Replace_</td></tr><tr><td>replace_if_(first, last, op&#7491;, new_value)</td><td>ReplaceIf_</td></tr><tr><td>replace_copy_(first,
 last, result, old_value,
+ new_value)</td><td>ReplaceCopy_</td></tr><tr><td>replace_copy_if_(first, last, result, op&#7491;, new_value)</td><td>ReplaceCopyIf_</td></tr><tr><td>rotate_(first, middle, last)&#7495;</td><td>Rotate_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e4993"></a><p class="title"><b>Table&nbsp;8.4.&nbsp;STL container methods</b></p><div class="table-contents"><table summary="STL container methods" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL container methods(common) in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>container::reference front_(container)</td><td>Front_</td></tr><tr><td>container::reference back_(container)</td><td>Back_</td></tr><tr><td>container::iterator begin_(container)</td><td>Begin_</td></tr><tr><td>container::iterator end_(container)</td><td>End_</td></tr><tr><td>container::reverse_iterator rbegin_(container)</td><td>RBegin_</td></tr><tr><td>container::reverse_iterator rend_(container)</td><td>REnd_</td></tr><tr><td>void push_back_(container, value)</td><td>Push_Back_</td></tr><tr><td>void pop_back_(container, value)</td><td>Pop_Back_</td></tr><tr><td>void push_front_(container, value)</td><td>Push_Front_</td></tr><tr><td>void pop_front_(container, val
ue)</td><td>Pop_Front_</td></tr><tr><td>void clear_(container)</td><td>Clear_</td></tr><tr><td>size_type capacity_(container)</td><td>Capacity_</td></tr><tr><td>size_type size_(container)</td><td>Size_</td></tr><tr><td>size_type max_size_(container)</td><td>Max_Size_</td></tr><tr><td>void reserve_(container, value)</td><td>Reserve _</td></tr><tr><td>void resize_(container, value)</td><td>Resize _</td></tr><tr><td>iterator insert_(container, pos, value)</td><td>Insert_</td></tr><tr><td>void insert_( container , pos, first, last)</td><td>Insert_</td></tr><tr><td>void insert_( container , pos, number, value)</td><td>Insert_</td></tr><tr><td>void swap_( container , other_container)</td><td>Swap_</td></tr><tr><td>void erase_( container , pos)</td><td>Erase_</td></tr><tr><td>void erase_( container , first, last) </td><td>Erase_</td></tr><tr><td>bool empty_( container)</td><td>Empty_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5124"></a><p class="title"><b>Table&nbsp;8.5.&nbsp;STL list methods</b></p><div class="table-contents"><table summary="STL list methods" border="1"><colgroup><col><col></colgroup><thead><tr><th>std::list methods in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>void list_remove_(container, value)</td><td>ListRemove_</td></tr><tr><td>void list_remove_if_(container, op&#7491;)</td><td>ListRemove_If_</td></tr><tr><td>void list_merge_(container, other_list)</td><td>ListMerge_</td></tr><tr><td>void list_merge_(container, other_list, op&#7491;)</td><td>ListMerge_</td></tr><tr><td>void splice_(container, iterator, other_list)</td><td>Splice_</td></tr><tr><td>void splice_(container, iterator, other_list,
+ iterator)</td><td>Splice_</td></tr><tr><td>void splice_(container, iterator, other_list, first,
+ last)</td><td>Splice_</td></tr><tr><td>void list_reverse_(container)</td><td>ListReverse_</td></tr><tr><td>void list_unique_(container)</td><td>ListUnique_</td></tr><tr><td>void list_unique_(container, op&#7491;)</td><td>ListUnique_</td></tr><tr><td>void list_sort_(container)</td><td>ListSort_</td></tr><tr><td>void list_sort_(container, op&#7491;)</td><td>ListSort_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5200"></a><p class="title"><b>Table&nbsp;8.6.&nbsp;STL associative container methods </b></p><div class="table-contents"><table summary="STL associative container methods " border="1"><colgroup><col><col></colgroup><thead><tr><th>Associative container methods in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>iterator insert_(container, pos, value)</td><td>Insert_</td></tr><tr><td>void insert_( container , first, last)</td><td>Insert_</td></tr><tr><td>pair&lt;iterator, bool&gt; insert_( container , value)</td><td>Insert_</td></tr><tr><td>void associative_erase_( container , pos)</td><td>Associative_Erase_</td></tr><tr><td>void associative_erase_( container , first, last)</td><td>Associative_Erase_</td></tr><tr><td>size_type associative_erase_( container , key)</td><td>Associative_Erase_</td></tr><tr><td>iterator associative_find_( container , key)</td><td>Associative_Find_</td></tr><tr><td>size_type associative_count_( container , key)</td><td
>AssociativeCount_</td></tr><tr><td>iterator associative_lower_bound_( container , key)</td><td>Associative_Lower_Bound_</td></tr><tr><td>iterator associative_upper_bound_( container , key)</td><td>Associative_Upper_Bound_</td></tr><tr><td>pair&lt;iterator, iterator&gt; associative_equal_range_(
+ container , key)</td><td>Associative_Equal_Range_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5271"></a><p class="title"><b>Table&nbsp;8.7.&nbsp;STL pair</b></p><div class="table-contents"><table summary="STL pair" border="1"><colgroup><col><col></colgroup><thead><tr><th>std::pair in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>first_type first_(pair&lt;T1, T2&gt;)</td><td>First_</td></tr><tr><td>second_type second_(pair&lt;T1, T2&gt;)</td><td>Second_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5297"></a><p class="title"><b>Table&nbsp;8.8.&nbsp;STL string</b></p><div class="table-contents"><table summary="STL string" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>STL string method</th><th>std::string method in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>substr (size_type pos, size_type size)</td><td>string substr_(container, pos, length)</td><td>Substr_</td></tr><tr><td>int compare(string)</td><td>int string_compare_(container, another_string)</td><td>StringCompare_</td></tr><tr><td>int compare(char*)</td><td>int string_compare_(container, another_string)</td><td>StringCompare_</td></tr><tr><td>int compare(size_type pos, size_type size, string)</td><td>int string_compare_(container, pos, size,
+ another_string)</td><td>StringCompare_</td></tr><tr><td>int compare (size_type pos, size_type size, string, size_type
+ length)</td><td>int string_compare_(container, pos, size, another_string,
+ length)</td><td>StringCompare_</td></tr><tr><td>string&amp; append(const string&amp;)</td><td>string&amp; append_(container, another_string)</td><td>Append_</td></tr><tr><td>string&amp; append (charT*)</td><td>string&amp; append_(container, another_string)</td><td>Append_</td></tr><tr><td>string&amp; append (string , size_type pos, size_type
+ size)</td><td>string&amp; append_(container, other_string, pos,
+ size)</td><td>Append_</td></tr><tr><td>string&amp; append (charT*, size_type size)</td><td>string&amp; append_(container, another_string,
+ length)</td><td>Append_</td></tr><tr><td>string&amp; append (size_type size, charT)</td><td>string&amp; append_(container, size, char)</td><td>Append_</td></tr><tr><td>string&amp; append (iterator begin, iterator end)</td><td>string&amp; append_(container, begin, end)</td><td>Append_</td></tr><tr><td>string&amp; insert (size_type pos, charT*)</td><td>string&amp; string_insert_(container, pos,
+ other_string)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert(size_type pos, charT*,size_type n)</td><td>string&amp; string_insert_(container, pos, other_string,
+ n)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert(size_type pos,size_type n, charT
+ c)</td><td>string&amp; string_insert_(container, pos, n, c)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert (size_type pos, const string&amp;)</td><td>string&amp; string_insert_(container, pos,
+ other_string)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert (size_type pos, const string&amp;,
+ size_type pos1, size_type n)</td><td>string&amp; string_insert_(container, pos, other_string,
+ pos1, n)</td><td>StringInsert_</td></tr><tr><td>string&amp; erase(size_type pos=0, size_type n=npos)</td><td>string&amp; string_erase_(container, pos, n)</td><td>StringErase_</td></tr><tr><td>string&amp; assign(const string&amp;)</td><td>string&amp; string_assign_(container, another_string)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const charT*)</td><td>string&amp; string_assign_(container, another_string)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const string&amp;, size_type pos,
+ size_type n)</td><td>string&amp; string_assign_(container, another_string, pos,
+ n)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const charT*, size_type n)</td><td>string&amp; string_assign_(container, another_string,
+ n)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(size_type n, charT c)</td><td>string&amp; string_assign_(container, n, c)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(iterator first, iterator last)</td><td>string&amp; string_assign_(container, first, last)</td><td>StringAssign_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const
+ string&amp;)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const charT*,
+ size_type n1)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string, n1)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const
+ charT*)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, size_type n1,
+ charT c)</td><td>string&amp; string_replace_(container, pos, n, n1, c)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ string&amp;)</td><td>string&amp; string_replace_(container, first, last,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ charT*, size_type n)</td><td>string&amp; string_replace_(container, first, last,
+ another_string, n)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ charT*)</td><td>string&amp; string_replace_(container, first, last,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, size_type
+ n, charT c)</td><td>string&amp; string_replace_(container, first, last, n,
+ c)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, iterator
+ f, iterator l)</td><td>string&amp; string_replace_(container, first, last, f,
+ l)</td><td>StringReplace_</td></tr><tr><td>const charT* c_str()</td><td>const charT* c_str_(container)</td><td>CStr_</td></tr><tr><td>const charT* data()</td><td>const charT* string_data_(container)</td><td>StringData_</td></tr><tr><td>size_type copy(charT* buf, size_type n, size_type pos =
+ 0)</td><td>size_type string_copy_(container, buf, n, pos); size_type
+ string_copy_(container, buf, n) </td><td>StringCopy_</td></tr><tr><td>size_type find(charT* s, size_type pos, size_type n)</td><td>size_type string_find_(container, s, pos, n)</td><td>StringFind_</td></tr><tr><td>size_type find(charT* s, size_type pos=0)</td><td>size_type string_find_(container, s, pos); size_type
+ string_find_(container, s) </td><td>StringFind_</td></tr><tr><td>size_type find(const string&amp; s, size_type pos=0)</td><td>size_type string_find_(container, s, pos) size_type
+ string_find_(container, s) </td><td>StringFind_</td></tr><tr><td>size_type find(charT c, size_type pos=0)</td><td>size_type string_find_(container, c, pos) size_type
+ string_find_(container, c) </td><td>StringFind_</td></tr><tr><td>size_type rfind(charT* s, size_type pos, size_type n)</td><td>size_type string_rfind_(container, s, pos, n)</td><td>StringRFind_</td></tr><tr><td>size_type rfind(charT* s, size_type pos=npos)</td><td>size_type string_rfind_(container, s, pos); size_type
+ string_rfind_(container, s) </td><td>StringRFind_</td></tr><tr><td>size_type rfind(const string&amp; s, size_type
+ pos=npos)</td><td>size_type string_rfind_(container, s, pos); size_type
+ string_rfind_(container, s) </td><td>StringRFind_</td></tr><tr><td>size_type rfind(charT c, size_type pos=npos)</td><td>size_type string_rfind_(container, c, pos) size_type
+ string_rfind_(container, c) </td><td>StringRFind_</td></tr><tr><td>size_type find_first_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_first_of_(container, s, pos, n)</td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (charT* s, size_type pos=0)</td><td>size_type find_first_of_(container, s, pos); size_type
+ find_first_of_(container, s) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (const string&amp; s, size_type
+ pos=0)</td><td>size_type find_first_of_(container, s, pos); size_type
+ find_first_of_(container, s) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (charT c, size_type pos=0)</td><td>size_type find_first_of_(container, c, pos) size_type
+ find_first_of_(container, c) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_not_of(charT* s, size_type pos,
+ size_type n)</td><td>size_type find_first_not_of_(container, s, pos, n)</td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (charT* s, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, s, pos); size_type
+ find_first_not_of_(container, s) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (const string&amp; s, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, s, pos); size_type
+ find_first_not_of_(container, s) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (charT c, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, c, pos); size_type
+ find_first_not_of_(container, c) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_last_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_last_of_(container, s, pos, n)</td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (charT* s, size_type pos=npos)</td><td>size_type find_last_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (const string&amp; s, size_type
+ pos=npos)</td><td>size_type find_last_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (charT c, size_type pos=npos)</td><td>size_type find_last_of_(container, c, pos); size_type
+ find_last_of_(container, c) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_not_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_last_not_of_(container, s, pos, n)</td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (charT* s, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (const string&amp; s, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, s, pos); size_type
+ find_last_not_of_(container, s) </td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (charT c, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, c, pos); size_type
+ find_last_not_of_(container, c) </td><td>StringFindLastNotOf_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p><span class="underline">Notes</span>: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>&#7491;: algorithms requiring a predicate need to make them eUML compatible
+ by wrapping them inside a Predicate_ functor. For example,
+ std::less&lt;int&gt; =&gt; Predicate_&lt;std::less&lt;int&gt; &gt;()</p></li><li class="listitem"><p>&#7495;: If using the SGI STL implementation, these functors use the SGI
+ return value</p></li></ul></div><p>
+ </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch08s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch08.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="rn01.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">eUML functions&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Reference</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch09.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch09.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,24 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;9.&nbsp;eUML operators and basic helpers</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt02.html" title="Part&nbsp;II.&nbsp;Reference"><link rel="prev" href="pt02.html" title="Part&nbsp;II.&nbsp;Reference"><link rel="next" href="ch10.html" title="Chapter&nbsp;10.&nbsp; Functional programming"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;9.&nbsp;eUML operators and basic helpers</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="pt02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;II.&nbsp;Reference</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch10.html">Next</a></td></tr></table><hr></div><div cl
ass="chapter" title="Chapter&nbsp;9.&nbsp;eUML operators and basic helpers"><div class="titlepage"><div><div><h2 class="title"><a name="d0e4607"></a>Chapter&nbsp;9.&nbsp;eUML operators and basic helpers</h2></div></div></div><p>The following table lists the supported operators: </p><p>
+ </p><div class="table"><a name="d0e4614"></a><p class="title"><b>Table&nbsp;9.1.&nbsp;Operators and state machine helpers</b></p><div class="table-contents"><table summary="Operators and state machine helpers" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>eUML function / operator</th><th>Description</th><th>Functor</th></tr></thead><tbody><tr><td>&amp;&amp;</td><td>Calls lazily Action1&amp;&amp; Action2</td><td>And_</td></tr><tr><td>||</td><td>Calls lazily Action1|| Action2</td><td>Or_</td></tr><tr><td>!</td><td>Calls lazily !Action1</td><td>Not_</td></tr><tr><td>!=</td><td>Calls lazily Action1 != Action2</td><td>NotEqualTo_</td></tr><tr><td>==</td><td>Calls lazily Action1 == Action2</td><td>EqualTo_</td></tr><tr><td>&gt;</td><td>Calls lazily Action1 &gt; Action2</td><td>Greater_</td></tr><tr><td>&gt;=</td><td>Calls lazily Action1 &gt;= Action2</td><td>Greater_Equal_</td></tr><tr><td>&lt;</td><td>Calls lazily Action1 &lt; Action2</td><td>Less_</td></tr><tr><td>&lt;=</td><td>C
alls lazily Action1 &lt;= Action2</td><td>Less_Equal_</td></tr><tr><td>&amp;</td><td>Calls lazily Action1 &amp; Action2</td><td>Bitwise_And_</td></tr><tr><td>|</td><td>Calls lazily Action1 | Action2</td><td>Bitwise_Or_</td></tr><tr><td>^</td><td>Calls lazily Action1 ^ Action2</td><td>Bitwise_Xor_</td></tr><tr><td>--</td><td>Calls lazily --Action1 / Action1--</td><td>Pre_Dec_ / Post_Dec_</td></tr><tr><td>++</td><td>Calls lazily ++Action1 / Action1++</td><td>Pre_Inc_ / Post_Inc_</td></tr><tr><td>/</td><td>Calls lazily Action1 / Action2</td><td>Divides_</td></tr><tr><td>/=</td><td>Calls lazily Action1 /= Action2</td><td>Divides_Assign_</td></tr><tr><td>*</td><td>Calls lazily Action1 * Action2</td><td>Multiplies_</td></tr><tr><td>*=</td><td>Calls lazily Action1 *= Action2</td><td>Multiplies_Assign_</td></tr><tr><td>+ (binary)</td><td>Calls lazily Action1 + Action2</td><td>Plus_</td></tr><tr><td>+ (unary)</td><td>Calls lazily +Action1</td><td>Unary_Plus_</td></tr><tr><td>+=</td><td>Calls lazily Action1 += Action2
</td><td>Plus_Assign_</td></tr><tr><td>- (binary)</td><td>Calls lazily Action1 - Action2</td><td>Minus_</td></tr><tr><td>- (unary)</td><td>Calls lazily -Action1</td><td>Unary_Minus_</td></tr><tr><td>-=</td><td>Calls lazily Action1 -= Action2</td><td>Minus_Assign_</td></tr><tr><td>%</td><td>Calls lazily Action1 % Action2</td><td>Modulus_</td></tr><tr><td>%=</td><td>Calls lazily Action1 %= Action2</td><td>Modulus_Assign_</td></tr><tr><td>&gt;&gt;</td><td>Calls lazily Action1 &gt;&gt; Action2</td><td>ShiftRight_</td></tr><tr><td>&gt;&gt;=</td><td>Calls lazily Action1 &gt;&gt;= Action2</td><td>ShiftRight_Assign_</td></tr><tr><td>&lt;&lt;</td><td>Calls lazily Action1 &lt;&lt; Action2</td><td>ShiftLeft_</td></tr><tr><td>&lt;&lt;=</td><td>Calls lazily Action1 &lt;&lt;= Action2</td><td>ShiftLeft_Assign_</td></tr><tr><td>[] (works on vector, map, arrays)</td><td>Calls lazily Action1 [Action2]</td><td>Subscript_</td></tr><tr><td>if_then_else_(Condition,Action1,Action2)</td><td>Returns either the result of calling Acti
on1 or the result of
+ calling Action2</td><td>If_Else_</td></tr><tr><td>if_then_(Condition,Action)</td><td>Returns the result of calling Action if Condition</td><td>If_Then_</td></tr><tr><td>while_(Condition, Body)</td><td>While Condition(), calls Body(). Returns nothing</td><td>While_Do_</td></tr><tr><td>do_while_(Condition, Body)</td><td>Calls Body() while Condition(). Returns nothing</td><td>Do_While_</td></tr><tr><td>for_(Begin,Stop,EndLoop,Body)</td><td>Calls for(Begin;Stop;EndLoop){Body;}</td><td>For_Loop_</td></tr><tr><td>process_(Event [,fsm1] [,fsm2] [,fsm3] [,fsm4])</td><td>Processes Event on the current state machine (if no fsm
+ specified) or on up to 4 state machines returned by an
+ appropriate functor.</td><td>Process_</td></tr><tr><td>process2_(Event, Data [,fsm1] [,fsm2] [,fsm3])</td><td>Processes Event on the current state machine (if no fsm
+ specified) or on up to 2 state machines returned by an
+ appropriate functor. The event is copy-constructed from what
+ Data() returns.</td><td>Process2_</td></tr><tr><td>is_flag_(Flag [,fsm])</td><td>Calls is_flag_active() on the current state machine or the
+ one returned by calling fsm.</td><td>Get_Flag_</td></tr><tr><td>event_ [(attribute name)]</td><td>Returns the current event (as const reference)</td><td>GetEvent_</td></tr><tr><td>source_ [(attribute name)]</td><td>Returns the source state of the currently triggered
+ transition (as reference). If an attribute name is provided,
+ returns the attribute by reference.</td><td>GetSource_</td></tr><tr><td>target_ [(attribute name)]</td><td>Returns the target state of the currently triggered
+ transition (as reference). If an attribute name is provided,
+ returns the attribute by reference.</td><td>GetTarget_</td></tr><tr><td>state_ [(attribute name)]</td><td>Returns the source state of the currently active state (as
+ reference). Valid inside a state entry/exit action. If an
+ attribute name is provided, returns the attribute by
+ reference.</td><td>GetState_</td></tr><tr><td>fsm_ [(attribute name)]</td><td>Returns the current state machine (as reference). Valid
+ inside a state entry/exit action or a transition. If an
+ attribute name is provided, returns the attribute by
+ reference.</td><td>GetFsm_</td></tr><tr><td>substate_(state_name [,fsm])</td><td>Returns (as reference) the state state_name referenced in the
+ current state machine or the one given as argument.</td><td>SubState_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>To use these functions, you need to include: </p><p><code class="code">#include &lt;msm/front/euml/euml.hpp&gt;</code></p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="pt02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch10.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Part&nbsp;II.&nbsp;Reference&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;10.&nbsp;
+ Functional programming </td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/ch10.html
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/ch10.html 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,100 @@
+<html><head>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+ <title>Chapter&nbsp;10.&nbsp; Functional programming</title><link rel="stylesheet" href="boostbook.css" type="text/css"><meta name="generator" content="DocBook XSL-NS Stylesheets V1.75.2"><link rel="home" href="index.html" title="Meta State Machine (MSM) V2.10"><link rel="up" href="pt02.html" title="Part&nbsp;II.&nbsp;Reference"><link rel="prev" href="ch09.html" title="Chapter&nbsp;9.&nbsp;eUML operators and basic helpers"><link rel="next" href="re01.html" title="Common headers"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;10.&nbsp;
+ Functional programming </th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch09.html">Prev</a>&nbsp;</td><th width="60%" align="center">Part&nbsp;II.&nbsp;Reference</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="re01.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;10.&nbsp; Functional programming"><div class="titlepage"><div><div><h2 class="title"><a name="d0e4951"></a>Chapter&nbsp;10.&nbsp;
+ <span class="command"><strong><a name="eUML-STL-all"></a></strong></span>Functional programming </h2></div></div></div><p>To use these functions, you need to include: </p><p><code class="code">#include &lt;msm/front/euml/stl.hpp&gt;</code></p><p>or the specified header in the following tables.</p><p>The following tables list the supported STL algorithms: </p><p>
+ <span class="command"><strong><a name="eUML-STL-querying"></a></strong></span>
+ </p><div class="table"><a name="d0e4969"></a><p class="title"><b>Table&nbsp;10.1.&nbsp;STL algorithms</b></p><div class="table-contents"><table summary="STL algorithms" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL algorithms in querying.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>find_(first, last, value)</td><td>Find_</td></tr><tr><td>find_if_(first, last, value)</td><td>FindIf_</td></tr><tr><td>lower_bound_(first, last, value [,op&#7491;])</td><td>LowerBound_</td></tr><tr><td>upper_bound_(first, last, value [,op&#7491;])</td><td>UpperBound_</td></tr><tr><td>equal_range_(first, last, value [,op&#7491;])</td><td>EqualRange_</td></tr><tr><td>binary_search_(first, last, value [,op&#7491;])</td><td>BinarySearch_</td></tr><tr><td>min_element_(first, last[,op&#7491;])</td><td>MinElement_</td></tr><tr><td>max_element_(first, last[,op&#7491;])</td><td>MaxElement_</td></tr><tr><td>adjacent_find_(first, last[,op&#7491;])</td><td>AdjacentFind_</td></tr><tr><td>find_end_( first1
, last1, first2, last2 [,op &#7491;])</td><td>FindEnd_</td></tr><tr><td>find_first_of_( first1, last1, first2, last2 [,op &#7491;])</td><td>FindFirstOf_</td></tr><tr><td>equal_( first1, last1, first2 [,op &#7491;])</td><td>Equal_</td></tr><tr><td>search_( first1, last1, first2, last2 [,op &#7491;])</td><td>Search_</td></tr><tr><td>includes_( first1, last1, first2, last2 [,op &#7491;])</td><td>Includes_</td></tr><tr><td>lexicographical_compare_ ( first1, last1, first2, last2 [,op
+ &#7491;]) </td><td>LexicographicalCompare_</td></tr><tr><td>count_(first, last, value [,size])</td><td>Count_</td></tr><tr><td>count_if_(first, last, op &#7491; [,size])</td><td>CountIf_</td></tr><tr><td>distance_(first, last)</td><td>Distance_</td></tr><tr><td>mismatch _( first1, last1, first2 [,op &#7491;])</td><td>Mismatch_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ <span class="command"><strong><a name="eUML-STL-iteration"></a></strong></span>
+ </p><div class="table"><a name="d0e5082"></a><p class="title"><b>Table&nbsp;10.2.&nbsp;STL algorithms</b></p><div class="table-contents"><table summary="STL algorithms" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL algorithms in iteration.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>for_each_(first,last, unary op&#7491;)</td><td>ForEach_</td></tr><tr><td>accumulate_first, last, init [,op&#7491;])</td><td>Accumulate_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ <span class="command"><strong><a name="eUML-STL-transformation"></a></strong></span>
+ </p><div class="table"><a name="d0e5110"></a><p class="title"><b>Table&nbsp;10.3.&nbsp;STL algorithms</b></p><div class="table-contents"><table summary="STL algorithms" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL algorithms in transformation.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>copy_(first, last, result)</td><td>Copy_</td></tr><tr><td>copy_backward_(first, last, result)</td><td>CopyBackward_</td></tr><tr><td>reverse_(first, last)</td><td>Reverse_</td></tr><tr><td>reverse_copy_(first, last , result)</td><td>ReverseCopy_</td></tr><tr><td>remove_(first, last, value)</td><td>Remove_</td></tr><tr><td>remove_if_(first, last , op&#7491;)</td><td>RemoveIf_</td></tr><tr><td>remove_copy_(first, last , output, value)</td><td>RemoveCopy_</td></tr><tr><td>remove_copy_if_(first, last, output, op&#7491;)</td><td>RemoveCopyIf_</td></tr><tr><td>fill_(first, last, value)</td><td>Fill_</td></tr><tr><td>fill_n_(first, size, value)&#7495;</td><td>FillN_</td></tr><tr><td>generate_(
first, last, generator&#7491;)</td><td>Generate_</td></tr><tr><td>generate_(first, size, generator&#7491;)&#7495;</td><td>GenerateN_</td></tr><tr><td>unique_(first, last [,op&#7491;])</td><td>Unique_</td></tr><tr><td>unique_copy_(first, last, output [,op&#7491;])</td><td>UniqueCopy_</td></tr><tr><td>random_shuffle_(first, last [,op&#7491;])</td><td>RandomShuffle_</td></tr><tr><td>rotate_copy_(first, middle, last, output)</td><td>RotateCopy_</td></tr><tr><td>partition_ (first, last [,op&#7491;])</td><td>Partition_</td></tr><tr><td>stable_partition_ (first, last [,op&#7491;])</td><td>StablePartition_</td></tr><tr><td>stable_sort_(first, last [,op&#7491;])</td><td>StableSort_</td></tr><tr><td>sort_(first, last [,op&#7491;])</td><td>Sort_</td></tr><tr><td>partial_sort_(first, middle, last [,op&#7491;])</td><td>PartialSort_</td></tr><tr><td>partial_sort_copy_ (first, last, res_first, res_last [,op&#7491;]) </td><td>PartialSortCopy_</td></tr><tr><td>nth_element_(first, nth, last [,op&#7491;])</td><td>NthElement_</
td></tr><tr><td>merge_( first1, last1, first2, last2, output [,op &#7491;])</td><td>Merge_</td></tr><tr><td>inplace_merge_(first, middle, last [,op&#7491;])</td><td>InplaceMerge_</td></tr><tr><td>set_union_(first1, last1, first2, last2, output [,op
+ &#7491;])</td><td>SetUnion_</td></tr><tr><td>push_heap_(first, last [,op &#7491;])</td><td>PushHeap_</td></tr><tr><td>pop_heap_(first, last [,op &#7491;])</td><td>PopHeap_</td></tr><tr><td>make_heap_(first, last [,op &#7491;])</td><td>MakeHeap_</td></tr><tr><td>sort_heap_(first, last [,op &#7491;])</td><td>SortHeap_</td></tr><tr><td>next_permutation_(first, last [,op &#7491;])</td><td>NextPermutation_</td></tr><tr><td>prev_permutation_(first, last [,op &#7491;])</td><td>PrevPermutation_</td></tr><tr><td>inner_product_(first1, last1, first2, init [,op1&#7491;] [,op2&#7491;]) </td><td>InnerProduct_</td></tr><tr><td>partial_sum_(first, last, output [,op&#7491;])</td><td>PartialSum_</td></tr><tr><td>adjacent_difference_(first, last, output [,op&#7491;])</td><td>AdjacentDifference_</td></tr><tr><td>replace_(first, last, old_value, new_value)</td><td>Replace_</td></tr><tr><td>replace_if_(first, last, op&#7491;, new_value)</td><td>ReplaceIf_</td></tr><tr><td>replace_copy_(first,
 last, result, old_value,
+ new_value)</td><td>ReplaceCopy_</td></tr><tr><td>replace_copy_if_(first, last, result, op&#7491;, new_value)</td><td>ReplaceCopyIf_</td></tr><tr><td>rotate_(first, middle, last)&#7495;</td><td>Rotate_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ <span class="command"><strong><a name="eUML-STL-container"></a></strong></span>
+ </p><div class="table"><a name="d0e5328"></a><p class="title"><b>Table&nbsp;10.4.&nbsp;STL container methods</b></p><div class="table-contents"><table summary="STL container methods" border="1"><colgroup><col><col></colgroup><thead><tr><th>STL container methods(common) in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>container::reference front_(container)</td><td>Front_</td></tr><tr><td>container::reference back_(container)</td><td>Back_</td></tr><tr><td>container::iterator begin_(container)</td><td>Begin_</td></tr><tr><td>container::iterator end_(container)</td><td>End_</td></tr><tr><td>container::reverse_iterator rbegin_(container)</td><td>RBegin_</td></tr><tr><td>container::reverse_iterator rend_(container)</td><td>REnd_</td></tr><tr><td>void push_back_(container, value)</td><td>Push_Back_</td></tr><tr><td>void pop_back_(container, value)</td><td>Pop_Back_</td></tr><tr><td>void push_front_(container, value)</td><td>Push_Front_</td></tr><tr><td>void pop_front_(container, va
lue)</td><td>Pop_Front_</td></tr><tr><td>void clear_(container)</td><td>Clear_</td></tr><tr><td>size_type capacity_(container)</td><td>Capacity_</td></tr><tr><td>size_type size_(container)</td><td>Size_</td></tr><tr><td>size_type max_size_(container)</td><td>Max_Size_</td></tr><tr><td>void reserve_(container, value)</td><td>Reserve _</td></tr><tr><td>void resize_(container, value)</td><td>Resize _</td></tr><tr><td>iterator insert_(container, pos, value)</td><td>Insert_</td></tr><tr><td>void insert_( container , pos, first, last)</td><td>Insert_</td></tr><tr><td>void insert_( container , pos, number, value)</td><td>Insert_</td></tr><tr><td>void swap_( container , other_container)</td><td>Swap_</td></tr><tr><td>void erase_( container , pos)</td><td>Erase_</td></tr><tr><td>void erase_( container , first, last) </td><td>Erase_</td></tr><tr><td>bool empty_( container)</td><td>Empty_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5459"></a><p class="title"><b>Table&nbsp;10.5.&nbsp;STL list methods</b></p><div class="table-contents"><table summary="STL list methods" border="1"><colgroup><col><col></colgroup><thead><tr><th>std::list methods in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>void list_remove_(container, value)</td><td>ListRemove_</td></tr><tr><td>void list_remove_if_(container, op&#7491;)</td><td>ListRemove_If_</td></tr><tr><td>void list_merge_(container, other_list)</td><td>ListMerge_</td></tr><tr><td>void list_merge_(container, other_list, op&#7491;)</td><td>ListMerge_</td></tr><tr><td>void splice_(container, iterator, other_list)</td><td>Splice_</td></tr><tr><td>void splice_(container, iterator, other_list,
+ iterator)</td><td>Splice_</td></tr><tr><td>void splice_(container, iterator, other_list, first,
+ last)</td><td>Splice_</td></tr><tr><td>void list_reverse_(container)</td><td>ListReverse_</td></tr><tr><td>void list_unique_(container)</td><td>ListUnique_</td></tr><tr><td>void list_unique_(container, op&#7491;)</td><td>ListUnique_</td></tr><tr><td>void list_sort_(container)</td><td>ListSort_</td></tr><tr><td>void list_sort_(container, op&#7491;)</td><td>ListSort_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5535"></a><p class="title"><b>Table&nbsp;10.6.&nbsp;STL associative container methods </b></p><div class="table-contents"><table summary="STL associative container methods " border="1"><colgroup><col><col></colgroup><thead><tr><th>Associative container methods in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>iterator insert_(container, pos, value)</td><td>Insert_</td></tr><tr><td>void insert_( container , first, last)</td><td>Insert_</td></tr><tr><td>pair&lt;iterator, bool&gt; insert_( container , value)</td><td>Insert_</td></tr><tr><td>void associative_erase_( container , pos)</td><td>Associative_Erase_</td></tr><tr><td>void associative_erase_( container , first, last)</td><td>Associative_Erase_</td></tr><tr><td>size_type associative_erase_( container , key)</td><td>Associative_Erase_</td></tr><tr><td>iterator associative_find_( container , key)</td><td>Associative_Find_</td></tr><tr><td>size_type associative_count_( container , key)</td><t
d>AssociativeCount_</td></tr><tr><td>iterator associative_lower_bound_( container , key)</td><td>Associative_Lower_Bound_</td></tr><tr><td>iterator associative_upper_bound_( container , key)</td><td>Associative_Upper_Bound_</td></tr><tr><td>pair&lt;iterator, iterator&gt; associative_equal_range_(
+ container , key)</td><td>Associative_Equal_Range_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5606"></a><p class="title"><b>Table&nbsp;10.7.&nbsp;STL pair</b></p><div class="table-contents"><table summary="STL pair" border="1"><colgroup><col><col></colgroup><thead><tr><th>std::pair in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>first_type first_(pair&lt;T1, T2&gt;)</td><td>First_</td></tr><tr><td>second_type second_(pair&lt;T1, T2&gt;)</td><td>Second_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p>
+ </p><div class="table"><a name="d0e5632"></a><p class="title"><b>Table&nbsp;10.8.&nbsp;STL string</b></p><div class="table-contents"><table summary="STL string" border="1"><colgroup><col><col><col></colgroup><thead><tr><th>STL string method</th><th>std::string method in container.hpp</th><th>Functor</th></tr></thead><tbody><tr><td>substr (size_type pos, size_type size)</td><td>string substr_(container, pos, length)</td><td>Substr_</td></tr><tr><td>int compare(string)</td><td>int string_compare_(container, another_string)</td><td>StringCompare_</td></tr><tr><td>int compare(char*)</td><td>int string_compare_(container, another_string)</td><td>StringCompare_</td></tr><tr><td>int compare(size_type pos, size_type size, string)</td><td>int string_compare_(container, pos, size,
+ another_string)</td><td>StringCompare_</td></tr><tr><td>int compare (size_type pos, size_type size, string, size_type
+ length)</td><td>int string_compare_(container, pos, size, another_string,
+ length)</td><td>StringCompare_</td></tr><tr><td>string&amp; append(const string&amp;)</td><td>string&amp; append_(container, another_string)</td><td>Append_</td></tr><tr><td>string&amp; append (charT*)</td><td>string&amp; append_(container, another_string)</td><td>Append_</td></tr><tr><td>string&amp; append (string , size_type pos, size_type
+ size)</td><td>string&amp; append_(container, other_string, pos,
+ size)</td><td>Append_</td></tr><tr><td>string&amp; append (charT*, size_type size)</td><td>string&amp; append_(container, another_string,
+ length)</td><td>Append_</td></tr><tr><td>string&amp; append (size_type size, charT)</td><td>string&amp; append_(container, size, char)</td><td>Append_</td></tr><tr><td>string&amp; append (iterator begin, iterator end)</td><td>string&amp; append_(container, begin, end)</td><td>Append_</td></tr><tr><td>string&amp; insert (size_type pos, charT*)</td><td>string&amp; string_insert_(container, pos,
+ other_string)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert(size_type pos, charT*,size_type n)</td><td>string&amp; string_insert_(container, pos, other_string,
+ n)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert(size_type pos,size_type n, charT
+ c)</td><td>string&amp; string_insert_(container, pos, n, c)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert (size_type pos, const string&amp;)</td><td>string&amp; string_insert_(container, pos,
+ other_string)</td><td>StringInsert_</td></tr><tr><td>string&amp; insert (size_type pos, const string&amp;,
+ size_type pos1, size_type n)</td><td>string&amp; string_insert_(container, pos, other_string,
+ pos1, n)</td><td>StringInsert_</td></tr><tr><td>string&amp; erase(size_type pos=0, size_type n=npos)</td><td>string&amp; string_erase_(container, pos, n)</td><td>StringErase_</td></tr><tr><td>string&amp; assign(const string&amp;)</td><td>string&amp; string_assign_(container, another_string)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const charT*)</td><td>string&amp; string_assign_(container, another_string)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const string&amp;, size_type pos,
+ size_type n)</td><td>string&amp; string_assign_(container, another_string, pos,
+ n)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(const charT*, size_type n)</td><td>string&amp; string_assign_(container, another_string,
+ n)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(size_type n, charT c)</td><td>string&amp; string_assign_(container, n, c)</td><td>StringAssign_</td></tr><tr><td>string&amp; assign(iterator first, iterator last)</td><td>string&amp; string_assign_(container, first, last)</td><td>StringAssign_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const
+ string&amp;)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const charT*,
+ size_type n1)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string, n1)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, const
+ charT*)</td><td>string&amp; string_replace_(container, pos, n,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(size_type pos, size_type n, size_type n1,
+ charT c)</td><td>string&amp; string_replace_(container, pos, n, n1, c)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ string&amp;)</td><td>string&amp; string_replace_(container, first, last,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ charT*, size_type n)</td><td>string&amp; string_replace_(container, first, last,
+ another_string, n)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, const
+ charT*)</td><td>string&amp; string_replace_(container, first, last,
+ another_string)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, size_type
+ n, charT c)</td><td>string&amp; string_replace_(container, first, last, n,
+ c)</td><td>StringReplace_</td></tr><tr><td>string&amp; replace(iterator first, iterator last, iterator
+ f, iterator l)</td><td>string&amp; string_replace_(container, first, last, f,
+ l)</td><td>StringReplace_</td></tr><tr><td>const charT* c_str()</td><td>const charT* c_str_(container)</td><td>CStr_</td></tr><tr><td>const charT* data()</td><td>const charT* string_data_(container)</td><td>StringData_</td></tr><tr><td>size_type copy(charT* buf, size_type n, size_type pos =
+ 0)</td><td>size_type string_copy_(container, buf, n, pos); size_type
+ string_copy_(container, buf, n) </td><td>StringCopy_</td></tr><tr><td>size_type find(charT* s, size_type pos, size_type n)</td><td>size_type string_find_(container, s, pos, n)</td><td>StringFind_</td></tr><tr><td>size_type find(charT* s, size_type pos=0)</td><td>size_type string_find_(container, s, pos); size_type
+ string_find_(container, s) </td><td>StringFind_</td></tr><tr><td>size_type find(const string&amp; s, size_type pos=0)</td><td>size_type string_find_(container, s, pos) size_type
+ string_find_(container, s) </td><td>StringFind_</td></tr><tr><td>size_type find(charT c, size_type pos=0)</td><td>size_type string_find_(container, c, pos) size_type
+ string_find_(container, c) </td><td>StringFind_</td></tr><tr><td>size_type rfind(charT* s, size_type pos, size_type n)</td><td>size_type string_rfind_(container, s, pos, n)</td><td>StringRFind_</td></tr><tr><td>size_type rfind(charT* s, size_type pos=npos)</td><td>size_type string_rfind_(container, s, pos); size_type
+ string_rfind_(container, s) </td><td>StringRFind_</td></tr><tr><td>size_type rfind(const string&amp; s, size_type
+ pos=npos)</td><td>size_type string_rfind_(container, s, pos); size_type
+ string_rfind_(container, s) </td><td>StringRFind_</td></tr><tr><td>size_type rfind(charT c, size_type pos=npos)</td><td>size_type string_rfind_(container, c, pos) size_type
+ string_rfind_(container, c) </td><td>StringRFind_</td></tr><tr><td>size_type find_first_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_first_of_(container, s, pos, n)</td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (charT* s, size_type pos=0)</td><td>size_type find_first_of_(container, s, pos); size_type
+ find_first_of_(container, s) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (const string&amp; s, size_type
+ pos=0)</td><td>size_type find_first_of_(container, s, pos); size_type
+ find_first_of_(container, s) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_of (charT c, size_type pos=0)</td><td>size_type find_first_of_(container, c, pos) size_type
+ find_first_of_(container, c) </td><td>StringFindFirstOf_</td></tr><tr><td>size_type find_first_not_of(charT* s, size_type pos,
+ size_type n)</td><td>size_type find_first_not_of_(container, s, pos, n)</td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (charT* s, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, s, pos); size_type
+ find_first_not_of_(container, s) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (const string&amp; s, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, s, pos); size_type
+ find_first_not_of_(container, s) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_first_not_of (charT c, size_type
+ pos=0)</td><td>size_type find_first_not_of_(container, c, pos); size_type
+ find_first_not_of_(container, c) </td><td>StringFindFirstNotOf_</td></tr><tr><td>size_type find_last_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_last_of_(container, s, pos, n)</td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (charT* s, size_type pos=npos)</td><td>size_type find_last_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (const string&amp; s, size_type
+ pos=npos)</td><td>size_type find_last_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_of (charT c, size_type pos=npos)</td><td>size_type find_last_of_(container, c, pos); size_type
+ find_last_of_(container, c) </td><td>StringFindLastOf_</td></tr><tr><td>size_type find_last_not_of(charT* s, size_type pos, size_type
+ n)</td><td>size_type find_last_not_of_(container, s, pos, n)</td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (charT* s, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, s, pos); size_type
+ find_last_of_(container, s) </td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (const string&amp; s, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, s, pos); size_type
+ find_last_not_of_(container, s) </td><td>StringFindLastNotOf_</td></tr><tr><td>size_type find_last_not_of (charT c, size_type
+ pos=npos)</td><td>size_type find_last_not_of_(container, c, pos); size_type
+ find_last_not_of_(container, c) </td><td>StringFindLastNotOf_</td></tr></tbody></table></div></div><p><br class="table-break">
+ </p><p><span class="underline">Notes</span>: </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>&#7491;: algorithms requiring a predicate need to make them eUML compatible
+ by wrapping them inside a Predicate_ functor. For example,
+ std::less&lt;int&gt; =&gt; Predicate_&lt;std::less&lt;int&gt; &gt;()</p></li><li class="listitem"><p>&#7495;: If using the SGI STL implementation, these functors use the SGI
+ return value</p></li></ul></div><p>
+ </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch09.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="pt02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="re01.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;9.&nbsp;eUML operators and basic helpers&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Common headers</td></tr></table></div></body></html>
\ No newline at end of file

Added: sandbox/msm/libs/msm/doc/HTML/docutils.css
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/docutils.css 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,275 @@
+/*
+:Author: David Goodger
+:Contact: goodger_at_[hidden]
+:Date: $Date: 2007-11-25 19:34:32 +0000 (Sun, 25 Nov 2007) $
+:Revision: $Revision: 41371 $
+:Copyright: This stylesheet has been placed in the public domain.
+
+Default cascading style sheet for the HTML output of Docutils.
+
+See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
+customize this style sheet.
+*/
+
+/* used to remove borders from tables and images */
+.borderless, table.borderless td, table.borderless th {
+ border: 0 }
+
+table.borderless td, table.borderless th {
+ /* Override padding for "table.docutils td" with "! important".
+ The right padding separates the table cells. */
+ padding: 0 0.5em 0 0 ! important }
+
+.first {
+ /* Override more specific margin styles with "! important". */
+ margin-top: 0 ! important }
+
+.last, .with-subtitle {
+ margin-bottom: 0 ! important }
+
+.hidden {
+ display: none }
+
+a.toc-backref {
+ text-decoration: none ;
+ color: black }
+
+blockquote.epigraph {
+ margin: 2em 5em ; }
+
+dl.docutils dd {
+ margin-bottom: 0.5em }
+
+/* Uncomment (and remove this text!) to get bold-faced definition list terms
+dl.docutils dt {
+ font-weight: bold }
+*/
+
+div.abstract {
+ margin: 2em 5em }
+
+div.abstract p.topic-title {
+ font-weight: bold ;
+ text-align: center }
+
+div.admonition, div.attention, div.caution, div.danger, div.error,
+div.hint, div.important, div.note, div.tip, div.warning {
+ margin: 2em ;
+ border: medium outset ;
+ padding: 1em }
+
+div.admonition p.admonition-title, div.hint p.admonition-title,
+div.important p.admonition-title, div.note p.admonition-title,
+div.tip p.admonition-title {
+ font-weight: bold ;
+ font-family: sans-serif }
+
+div.attention p.admonition-title, div.caution p.admonition-title,
+div.danger p.admonition-title, div.error p.admonition-title,
+div.warning p.admonition-title {
+ color: red ;
+ font-weight: bold ;
+ font-family: sans-serif }
+
+/* Uncomment (and remove this text!) to get reduced vertical space in
+ compound paragraphs.
+div.compound .compound-first, div.compound .compound-middle {
+ margin-bottom: 0.5em }
+
+div.compound .compound-last, div.compound .compound-middle {
+ margin-top: 0.5em }
+*/
+
+div.dedication {
+ margin: 2em 5em ;
+ text-align: center ;
+ font-style: italic }
+
+div.dedication p.topic-title {
+ font-weight: bold ;
+ font-style: normal }
+
+div.figure {
+ margin-left: 2em ;
+ margin-right: 2em }
+
+div.footer, div.header {
+ clear: both;
+ font-size: smaller }
+
+div.line-block {
+ display: block ;
+ margin-top: 1em ;
+ margin-bottom: 1em }
+
+div.line-block div.line-block {
+ margin-top: 0 ;
+ margin-bottom: 0 ;
+ margin-left: 1.5em }
+
+div.sidebar {
+ margin-left: 1em ;
+ border: medium outset ;
+ padding: 1em ;
+ background-color: #ffffee ;
+ width: 40% ;
+ float: right ;
+ clear: right }
+
+div.sidebar p.rubric {
+ font-family: sans-serif ;
+ font-size: medium }
+
+div.system-messages {
+ margin: 5em }
+
+div.system-messages h1 {
+ color: red }
+
+div.system-message {
+ border: medium outset ;
+ padding: 1em }
+
+div.system-message p.system-message-title {
+ color: red ;
+ font-weight: bold }
+
+div.topic {
+ margin: 2em }
+
+h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
+h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
+ margin-top: 0.4em }
+
+h1.title {
+ text-align: center }
+
+h2.subtitle {
+ text-align: center }
+
+hr.docutils {
+ width: 75% }
+
+img.align-left {
+ clear: left }
+
+img.align-right {
+ clear: right }
+
+ol.simple, ul.simple {
+ margin-bottom: 1em }
+
+ol.arabic {
+ list-style: decimal }
+
+ol.loweralpha {
+ list-style: lower-alpha }
+
+ol.upperalpha {
+ list-style: upper-alpha }
+
+ol.lowerroman {
+ list-style: lower-roman }
+
+ol.upperroman {
+ list-style: upper-roman }
+
+p.attribution {
+ text-align: right ;
+ margin-left: 50% }
+
+p.caption {
+ font-style: italic }
+
+p.credits {
+ font-style: italic ;
+ font-size: smaller }
+
+p.label {
+ white-space: nowrap }
+
+p.rubric {
+ font-weight: bold ;
+ font-size: larger ;
+ color: maroon ;
+ text-align: center }
+
+p.sidebar-title {
+ font-family: sans-serif ;
+ font-weight: bold ;
+ font-size: larger }
+
+p.sidebar-subtitle {
+ font-family: sans-serif ;
+ font-weight: bold }
+
+p.topic-title {
+ font-weight: bold }
+
+pre.address {
+ margin-bottom: 0 ;
+ margin-top: 0 ;
+ font-family: serif ;
+ font-size: 100% }
+
+pre.literal-block, pre.doctest-block {
+ margin-left: 2em ;
+ margin-right: 2em }
+
+span.classifier {
+ font-family: sans-serif ;
+ font-style: oblique }
+
+span.classifier-delimiter {
+ font-family: sans-serif ;
+ font-weight: bold }
+
+span.interpreted {
+ font-family: sans-serif }
+
+span.option {
+ white-space: nowrap }
+
+span.pre {
+ white-space: pre }
+
+span.problematic {
+ color: red }
+
+span.section-subtitle {
+ /* font-size relative to parent (h1..h6 element) */
+ font-size: 80% }
+
+table.citation {
+ border-left: solid 1px gray;
+ margin-left: 1px }
+
+table.docinfo {
+ margin: 2em 4em }
+
+table.docutils {
+ margin-top: 0.5em ;
+ margin-bottom: 0.5em }
+
+table.footnote {
+ border-left: solid 1px black;
+ margin-left: 1px }
+
+table.docutils td, table.docutils th,
+table.docinfo td, table.docinfo th {
+ padding-left: 0.5em ;
+ padding-right: 0.5em ;
+ vertical-align: top }
+
+table.docutils th.field-name, table.docinfo th.docinfo-name {
+ font-weight: bold ;
+ text-align: left ;
+ white-space: nowrap ;
+ padding-left: 0 }
+
+h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
+h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
+ font-size: 100% }
+
+ul.auto-toc {
+ list-style-type: none }

Added: sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorial.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorial.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,122 @@
+#include <iostream>
+// back-end
+#include <boost/msm/back/state_machine.hpp>
+//front-end
+#include <boost/msm/front/state_machine_def.hpp>
+
+namespace msm = boost::msm;
+using namespace boost::msm::front;
+
+namespace
+{
+ // events
+ struct event1 {};
+
+
+ // front-end: define the FSM structure
+ struct my_machine_ : public msm::front::state_machine_def<my_machine_>
+ {
+ // The list of FSM states
+ struct State1 : public msm::front::state<>
+ {
+ // every (optional) entry/exit methods get the event passed.
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: State1" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State1" << std::endl;}
+ };
+ struct State2 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const& ,FSM&) {std::cout << "entering: State2" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State2" << std::endl;}
+ };
+
+ struct State3 : public msm::front::state<>
+ {
+ // when stopped, the CD is loaded
+ template <class Event,class FSM>
+ void on_entry(Event const& ,FSM&) {std::cout << "entering: State3" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State3" << std::endl;}
+ };
+
+ struct State4 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: State4" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State4" << std::endl;}
+ };
+
+ // the initial state of the player SM. Must be defined
+ typedef State1 initial_state;
+
+ // transition actions
+ void State2ToState3(none const&) { std::cout << "my_machine::State2ToState3\n"; }
+ void State3ToState4(none const&) { std::cout << "my_machine::State3ToState4\n"; }
+ // guard conditions
+ bool always_true(none const& evt)
+ {
+ std::cout << "always_true" << std::endl;
+ return true;
+ }
+ bool always_false(none const& evt)
+ {
+ std::cout << "always_false" << std::endl;
+ return false;
+ }
+
+ typedef my_machine_ p; // makes transition table cleaner
+
+ // Transition table for player
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ _row < State1 , none , State2 >,
+ a_row < State2 , none , State3 , &p::State2ToState3 >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ row < State3 , none , State4 , &p::State3ToState4 , &p::always_true >,
+ g_row < State3 , none , State4 , &p::always_false >,
+ _row < State4 , event1 , State1 >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ // Pick a back-end
+ typedef msm::back::state_machine<my_machine_> my_machine;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "State1", "State2", "State3", "State4" };
+ void pstate(my_machine const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ my_machine p;
+
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ // in this case it will also immediately trigger all anonymous transitions
+ p.start();
+ // this event will bring us back to the initial state and thus, a new "loop" will be started
+ p.process_event(event1());
+
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorialEuml.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorialEuml.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,165 @@
+#include <iostream>
+// back-end
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/euml/euml.hpp>
+
+namespace msm = boost::msm;
+using namespace boost::msm::front::euml;
+
+namespace
+{
+ // events
+ BOOST_MSM_EUML_EVENT(event1)
+
+ BOOST_MSM_EUML_ACTION(State1_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: State1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State1_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: State1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State2_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: State2" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State2_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: State2" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State3_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: State3" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State3_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: State3" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State4_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: State4" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State4_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: State4" << std::endl;
+ }
+ };
+
+ // The list of FSM states
+ BOOST_MSM_EUML_STATE(( State1_Entry,State1_Exit ),State1)
+ BOOST_MSM_EUML_STATE(( State2_Entry,State2_Exit ),State2)
+ BOOST_MSM_EUML_STATE(( State3_Entry,State3_Exit ),State3)
+ BOOST_MSM_EUML_STATE(( State4_Entry,State4_Exit ),State4)
+
+ // transition actions
+ BOOST_MSM_EUML_ACTION(State2ToState3)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ std::cout << "my_machine::State2ToState3" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State3ToState4)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ std::cout << "my_machine::State3ToState4" << std::endl;
+ }
+ };
+ // guard conditions
+ BOOST_MSM_EUML_ACTION(always_true)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ bool operator()(EVT const& evt,FSM&,SourceState& ,TargetState& )
+ {
+ std::cout << "always_true" << std::endl;
+ return true;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(always_false)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ bool operator()(EVT const& evt,FSM&,SourceState& ,TargetState& )
+ {
+ std::cout << "always_false" << std::endl;
+ return false;
+ }
+ };
+ // replaces the old transition table
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ State2 == State1 ,
+ State3 == State2 / State2ToState3,
+ State4 == State3 [always_true] / State3ToState4,
+ State4 == State3 [always_false],
+ State1 == State4 + event1
+ // +------------------------------------------------------------------------------+
+ ),transition_table)
+
+ // create a state machine "on the fly"
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT
+ init_ << State1 // Init State
+ ),
+ my_machine_) //fsm name
+
+ // Pick a back-end
+ typedef msm::back::state_machine<my_machine_> my_machine;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "State1", "State2", "State3", "State4" };
+ void pstate(my_machine const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ my_machine p;
+
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ // in this case it will also immediately trigger all anonymous transitions
+ p.start();
+ // this event will bring us back to the initial state and thus, a new "loop" will be started
+ p.process_event(event1);
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorialWithFunctors.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/AnonymousTutorialWithFunctors.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,147 @@
+#include <iostream>
+// back-end
+#include <boost/msm/back/state_machine.hpp>
+//front-end
+#include <boost/msm/front/state_machine_def.hpp>
+// functors
+#include <boost/msm/front/functor_row.hpp>
+#include <boost/msm/front/euml/common.hpp>
+
+namespace msm = boost::msm;
+using namespace boost::msm::front;
+
+namespace
+{
+ // events
+ struct event1 {};
+
+
+ // front-end: define the FSM structure
+ struct my_machine_ : public msm::front::state_machine_def<my_machine_>
+ {
+ // The list of FSM states
+ struct State1 : public msm::front::state<>
+ {
+ // every (optional) entry/exit methods get the event passed.
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: State1" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State1" << std::endl;}
+ };
+ struct State2 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const& ,FSM&) {std::cout << "entering: State2" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State2" << std::endl;}
+ };
+
+ struct State3 : public msm::front::state<>
+ {
+ // when stopped, the CD is loaded
+ template <class Event,class FSM>
+ void on_entry(Event const& ,FSM&) {std::cout << "entering: State3" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State3" << std::endl;}
+ };
+
+ struct State4 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: State4" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State4" << std::endl;}
+ };
+
+ // the initial state of the player SM. Must be defined
+ typedef State1 initial_state;
+
+ // transition actions
+ struct State2ToState3
+ {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM& ,SourceState& ,TargetState& )
+ {
+ std::cout << "my_machine::State2ToState3" << std::endl;
+ }
+ };
+ struct State3ToState4
+ {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM& ,SourceState& ,TargetState& )
+ {
+ std::cout << "my_machine::State3ToState4" << std::endl;
+ }
+ };
+ // guard conditions
+ struct always_true
+ {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)
+ {
+ std::cout << "always_true" << std::endl;
+ return true;
+ }
+ };
+ struct always_false
+ {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)
+ {
+ std::cout << "always_false" << std::endl;
+ return true;
+ }
+ };
+
+ typedef my_machine_ p; // makes transition table cleaner
+
+ // Transition table for player
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ Row < State1 , none , State2 >,
+ Row < State2 , none , State3 , State2ToState3 >,
+ Row < State3 , none , State4 , none , always_false >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ Row < State3 , none , State4 , State3ToState4 , always_true >,
+ Row < State4 , event1 , State1 >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ // Pick a back-end
+ typedef msm::back::state_machine<my_machine_> my_machine;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "State1", "State2", "State3", "State4" };
+ void pstate(my_machine const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ my_machine p;
+
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ // in this case it will also immediately trigger all anonymous transitions
+ p.start();
+ // this event will bring us back to the initial state and thus, a new "loop" will be started
+ p.process_event(event1());
+
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/BoostCon09Full.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/BoostCon09Full.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,359 @@
+#include <vector>
+#include <iostream>
+#include <boost/mpl/vector/vector50.hpp>
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/state_machine_def.hpp>
+#include <boost/msm/back/tools.hpp>
+
+namespace msm = boost::msm;
+
+namespace // Concrete FSM implementation
+{
+ // events
+ struct play {};
+ struct end_pause {};
+ struct stop {};
+ struct pause {};
+ struct open_close {};
+ struct NextSong {};
+ // event which every other event can convert to
+ struct AllSongsPlayed
+ {
+ template <class Event>
+ AllSongsPlayed(Event const&){}
+ };
+ struct PreviousSong {};
+ struct error_found {};
+ struct end_error {};
+
+ // Flags. Allow information about a property of the current state
+ struct CDLoaded {};
+ struct FirstSongPlaying {};
+
+ // A "complicated" event type that carries some data.
+ enum DiskTypeEnum
+ {
+ DISK_CD=0,
+ DISK_DVD=1
+ };
+ struct cd_detected
+ {
+ cd_detected(DiskTypeEnum diskType): disc_type(diskType) {}
+ DiskTypeEnum disc_type;
+ };
+
+ // Concrete FSM implementation
+ struct player_ : public msm::front::state_machine_def<player_>
+ {
+ // The list of FSM states
+ struct Empty : public msm::front::state<>
+ {
+ typedef mpl::vector<play> deferred_events;
+ // every (optional) entry/exit methods get the event packed as boost::any. Not useful very often.
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Empty" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Empty" << std::endl;}
+ };
+ struct Open : public msm::front::state<>
+ {
+ typedef mpl::vector1<CDLoaded> flag_list;
+ typedef mpl::vector<play> deferred_events;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Open" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Open" << std::endl;}
+ };
+ // a state needing a pointer to the containing state machine
+ // and using for this the non-default policy
+ // if policy used, set_sm_ptr is needed
+ struct Stopped : public msm::front::state<default_base_state,msm::front::sm_ptr>
+ {
+ // when stopped, the CD is loaded
+ typedef mpl::vector1<CDLoaded> flag_list;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Stopped" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Stopped" << std::endl;}
+ void set_sm_ptr(player_* pl){m_player=pl;}
+ player_* m_player;
+ };
+ // the player state machine contains a state which is himself a state machine
+ // it demonstrates Shallow History: if the state gets activated with end_pause
+ // then it will remember the last active state and reactivate it
+ // also possible: AlwaysHistory, the last active state will always be reactivated
+ // or NoHistory, always restart from the initial state
+ struct Playing_ : public msm::front::state_machine_def<Playing_>
+ {
+ // when playing, the CD is loaded and we are in either pause or playing (duh)
+ typedef mpl::vector<CDLoaded> flag_list;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Playing" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Playing" << std::endl;}
+
+ // The list of FSM states
+ struct Song1 : public msm::front::state<>
+ {
+ typedef mpl::vector1<FirstSongPlaying> flag_list;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: First song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: First Song" << std::endl;}
+ };
+ struct Song2 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: Second song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: Second Song" << std::endl;}
+ };
+ struct Song3 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: Third song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: Third Song" << std::endl;}
+ };
+ struct CDFinished : public msm::front::exit_pseudo_state<AllSongsPlayed>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Playing::CDFinished" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Playing::CDFinished" << std::endl;}
+ };
+ // the initial state. Must be defined
+ typedef Song1 initial_state;
+ // transition actions
+ void start_next_song(NextSong const&) { std::cout << "Playing::start_next_song\n"; }
+ void start_prev_song(PreviousSong const&) { std::cout << "Playing::start_prev_song\n"; }
+ void all_songs_played(NextSong const&) { std::cout << "Playing::all_songs_played\n"; }
+ // guard conditions
+
+ typedef Playing_ pl; // makes transition table cleaner
+ // Transition table for Playing
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +---------+---------------+------------+---------------------+----------------------+
+ a_row < Song1 , NextSong , Song2 , &pl::start_next_song >,
+ a_row < Song2 , PreviousSong, Song1 , &pl::start_prev_song >,
+ a_row < Song2 , NextSong , Song3 , &pl::start_next_song >,
+ a_row < Song3 , PreviousSong, Song2 , &pl::start_prev_song >,
+ a_row < Song3 , NextSong , CDFinished , &pl::all_songs_played >
+ // +---------+---------------+---------+---------------------+----------------------+
+ > {};
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ typedef msm::back::state_machine<Playing_,msm::back::ShallowHistory<mpl::vector<end_pause> > > Playing;
+
+ // the player state machine contains a state which is himself a state machine (2 of them, Playing and Paused)
+ struct Paused : public msm::front::state<>
+ {
+ typedef mpl::vector<CDLoaded> flag_list;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Paused" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Paused" << std::endl;}
+ };
+
+ struct AllOk : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: AllOk" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: AllOk" << std::endl;}
+ };
+ struct ErrorMode : //public msm::front::terminate_state<>
+ public msm::front::interrupt_state<end_error>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: ErrorMode" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: ErrorMode" << std::endl;}
+ };
+
+ // the initial state of the player SM. Must be defined
+ typedef mpl::vector<Empty,AllOk> initial_state;
+
+ // transition actions
+ void start_playback(play const&) { std::cout << "player::start_playback\n"; }
+ void open_drawer(open_close const&) { std::cout << "player::open_drawer\n"; }
+ void close_drawer(open_close const&) { std::cout << "player::close_drawer\n"; }
+ void store_cd_info(cd_detected const&)
+ {
+ std::cout << "player::store_cd_info\n";
+ // generate another event to test the queue
+ //cd.m_player.process_event(play());
+ }
+ void stop_playback(stop const&) { std::cout << "player::stop_playback\n"; }
+ void end_playback (AllSongsPlayed const&) { std::cout << "player::end_playback\n"; }
+ void pause_playback(pause const&) { std::cout << "player::pause_playback\n"; }
+ void resume_playback(end_pause const&) { std::cout << "player::resume_playback\n"; }
+ void stop_and_open(open_close const&) { std::cout << "player::stop_and_open\n"; }
+ void stopped_again(stop const&) {std::cout << "player::stopped_again\n";}
+ void report_error(error_found const&) {std::cout << "player::report_error\n";}
+ void report_end_error(end_error const&) {std::cout << "player::report_end_error\n";}
+ // guard conditions
+ bool good_disk_format(cd_detected const& evt)
+ {
+ // to test a guard condition, let's say we understand only CDs, not DVD
+ if (evt.disc_type != DISK_CD)
+ {
+ std::cout << "wrong disk, sorry" << std::endl;
+ return false;
+ }
+ return true;
+ }
+
+ typedef player_ p; // makes transition table cleaner
+
+ // Transition table for player
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +-------------+---------------+---------+---------------------+----------------------+
+ a_row < Stopped , play , Playing , &p::start_playback >,
+ a_row < Stopped , open_close , Open , &p::open_drawer >,
+ a_row < Stopped , stop , Stopped , &p::stopped_again >,
+ // +-------------+---------------+---------+---------------------+----------------------+
+ a_row < Open , open_close , Empty , &p::close_drawer >,
+ // +-------------+---------------+---------+---------------------+----------------------+
+ a_row < Empty , open_close , Open , &p::open_drawer >,
+ row < Empty , cd_detected , Stopped , &p::store_cd_info ,&p::good_disk_format >,
+ // +-------------+---------------+---------+---------------------+----------------------+
+ a_row < Playing , stop , Stopped , &p::stop_playback >,
+ a_row < Playing , pause , Paused , &p::pause_playback >,
+ a_row < Playing , open_close , Open , &p::stop_and_open >,
+ a_row < Playing::exit_pt<
+ Playing_::CDFinished> , AllSongsPlayed, Stopped , &p::end_playback >,
+ // +-------------+---------------+---------+---------------------+----------------------+
+ a_row < Paused , end_pause , Playing , &p::resume_playback >,
+ a_row < Paused , stop , Stopped , &p::stop_playback >,
+ a_row < Paused , open_close , Open , &p::stop_and_open >,
+ // +-------------+---------------+---------+---------------------+----------------------+
+ a_row < AllOk , error_found ,ErrorMode, &p::report_error >,
+ a_row < ErrorMode ,end_error ,AllOk , &p::report_end_error >
+ // +-------------+---------------+---------+---------------------+----------------------+
+ > {};
+
+
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+
+ void pstate(player const& p)
+ {
+ typedef player::stt Stt;
+ typedef msm::back::generate_state_set<Stt>::type all_states;
+ static char const* state_names[mpl::size<all_states>::value];
+ // fill the names of the states defined in the state machine
+ mpl::for_each<all_states,boost::msm::wrap<mpl::placeholders::_1> >
+ (msm::back::fill_state_names<Stt>(state_names));
+
+ for (unsigned int i=0;i<player::nr_regions::value;++i)
+ {
+ std::cout << " -> " << state_names[p.current_state()[i]] << std::endl;
+ }
+ }
+
+ void test()
+ {
+ player p;
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ p.start();
+ std::cout << "CDLoaded active:" << std::boolalpha << p.is_flag_active<CDLoaded>() << std::endl; //=> false (no CD yet)
+
+ // test deferred event
+ // deferred in Empty and Open, will be handled only after event cd_detected
+ std::cout << "play is not handled in the current state but is marked as delayed" << std::endl;
+ p.process_event(play()); pstate(p);
+ std::cout << "cd_detected will cause play to be handled also" << std::endl;
+ // will be rejected, wrong disk type
+ p.process_event(cd_detected(DISK_DVD)); pstate(p);
+ // will be accepted, wrong disk type
+ p.process_event(cd_detected(DISK_CD)); pstate(p);
+
+ std::cout << "FirstSong active:" << std::boolalpha << p.is_flag_active<FirstSongPlaying>() << std::endl; //=> true
+ p.process_event(NextSong());pstate(p);
+ // We are now in second song, Flag inactive
+ std::cout << "FirstSong active:" << std::boolalpha << p.is_flag_active<FirstSongPlaying>() << std::endl;//=> false
+ p.process_event(NextSong());pstate(p);
+ // 2nd song active
+ p.process_event(PreviousSong());pstate(p);
+ // Pause
+ p.process_event(pause()); pstate(p);
+ // go back to Playing
+ // but end_pause is an event activating the History
+ // => keep the last active State (SecondSong)
+ p.process_event(end_pause()); pstate(p);
+ // force an exit by listening all the songs
+ p.process_event(NextSong());
+ p.process_event(NextSong());pstate(p);
+
+ std::cout << "CDLoaded active:" << std::boolalpha << p.is_flag_active<CDLoaded>() << std::endl;//=> true
+ std::cout << "FirstSong active:" << std::boolalpha << p.is_flag_active<FirstSongPlaying>() << std::endl;//=> false
+
+ // go back to Playing
+ // but play is not leading to Shallow History => do not remember the last active State (SecondSong)
+ // and activate again FirstSong and LightOn
+ p.process_event(play()); pstate(p);
+ p.process_event(error_found()); pstate(p);
+
+ // try generating more events
+ std::cout << "Trying to generate another event" << std::endl; // will not work, fsm is terminated or interrupted
+ p.process_event(NextSong());pstate(p);
+
+ std::cout << "Trying to end the error" << std::endl; // will work only if ErrorMode is interrupt state
+ p.process_event(end_error());pstate(p);
+ std::cout << "Trying to generate another event" << std::endl; // will work only if ErrorMode is interrupt state
+ p.process_event(NextSong());pstate(p);
+
+ // the states and events of the higher level FSM (player)
+ typedef player::stt Stt;
+ typedef msm::back::generate_state_set<Stt>::type simple_states;
+
+ std::cout << "the state list:" << std::endl;
+ mpl::for_each<simple_states,boost::msm::wrap<mpl::placeholders::_1> >(msm::back::display_type ());
+
+ std::cout << "the event list:" << std::endl;
+ typedef msm::back::generate_event_set<Stt>::type event_list;
+ mpl::for_each<event_list,boost::msm::wrap<mpl::placeholders::_1> >(msm::back::display_type ());
+ std::cout << std::endl;
+
+ // the states and events recursively searched
+ typedef msm::back::recursive_get_transition_table<player>::type recursive_stt;
+
+ std::cout << "the state list (including sub-SMs):" << std::endl;
+
+ typedef msm::back::generate_state_set<recursive_stt>::type all_states;
+ mpl::for_each<all_states,boost::msm::wrap<mpl::placeholders::_1> >(msm::back::display_type ());
+
+ std::cout << "the event list (including sub-SMs):" << std::endl;
+ typedef msm::back::generate_event_set<recursive_stt>::type all_events;
+ mpl::for_each<all_events,boost::msm::wrap<mpl::placeholders::_1> >(msm::back::display_type ());
+
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}
+
+

Added: sandbox/msm/libs/msm/doc/HTML/examples/CompilerStressTestEuml.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/CompilerStressTestEuml.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,436 @@
+#include <vector>
+#include <list>
+#include <set>
+#include <map>
+#include <iostream>
+
+// we need more than the default 10 states
+#define FUSION_MAX_VECTOR_SIZE 15
+
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/euml/euml.hpp>
+#include <boost/msm/front/euml/stl.hpp>
+
+using namespace std;
+using namespace boost::msm::front::euml;
+namespace msm = boost::msm;
+
+// how long the timer will ring when countdown elapsed.
+#define RINGING_TIME 5
+
+namespace // Concrete FSM implementation
+{
+ // flag
+ BOOST_MSM_EUML_FLAG(SomeFlag)
+
+ // declares attributes with type and name. Can be used anywhere after
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,m_song)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int,m_song_id)
+
+ // declare that a type inheriting from OneSongDef will get these 2 attributes
+ BOOST_MSM_EUML_ATTRIBUTES((attributes_ << m_song << m_song_id ), OneSongDef)
+ // events
+ // this event is done "manually", not using any predefined macro
+ struct OneSong_impl : euml_event<OneSong_impl>,OneSongDef
+ {
+ OneSong_impl(){}
+ OneSong_impl(const string& asong)
+ {
+ get_attribute(m_song)=asong;
+ get_attribute(m_song_id)=1;
+ }
+ OneSong_impl(const OneSong_impl& asong)
+ {
+ get_attribute(m_song)=asong.get_attribute(m_song);
+ get_attribute(m_song_id)=1;
+ }
+ const string& get_data() const {return get_attribute(m_song);}
+ };
+ // declare an instance for use in the transition table
+ OneSong_impl const OneSong;
+
+ struct SongComparator : euml_action<SongComparator>
+ {
+ bool operator()(const OneSong_impl& lhs,const OneSong_impl& rhs)const
+ {
+ return lhs.get_data() == rhs.get_data();
+ }
+ };
+ struct SongLessComparator : euml_action<SongLessComparator>
+ {
+ bool operator()(const OneSong_impl& lhs,const OneSong_impl& rhs)const
+ {
+ return lhs.get_data() < rhs.get_data();
+ }
+ };
+ struct Comparator
+ {
+ template <class T>
+ bool operator()(const T& lhs,const T& rhs)const
+ {
+ return lhs < rhs;
+ }
+ };
+ struct RemoveDummy
+ {
+ bool operator()(const OneSong_impl& lhs)const
+ {
+ return (lhs.get_attribute(m_song).compare(std::string("She-Dummy. Remove this one"))==0 );
+ }
+ };
+ template <int val>
+ struct LookFor
+ {
+ template <class T>
+ bool operator()(const T& lhs)const
+ {
+ return lhs == val;
+ }
+ };
+ template <int val>
+ struct LessThan
+ {
+ template <class T>
+ bool operator()(const T& lhs)const
+ {
+ return lhs < val;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SongDeleter)
+ {
+ bool operator()(const OneSong_impl& lhs)const
+ {
+ return lhs.get_data() == "Twist and Shout";
+ }
+ };
+ struct Generator
+ {
+ int operator()()const
+ {
+ return 1;
+ }
+ };
+ struct Print
+ {
+ template <class T>
+ void operator()(const T& lhs)const
+ {
+ std::cout << "Song:" << lhs.get_data() << endl;
+ }
+ };
+ BOOST_MSM_EUML_ATTRIBUTES((attributes_ << m_song ), NotFoundDef)
+ // declare an event instance called NotFound with the defined attributes
+ // these attributes can then be referenced anywhere (stt, state behaviors)
+ BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(NotFound,NotFoundDef)
+
+ BOOST_MSM_EUML_ATTRIBUTES((attributes_ << m_song ), FoundDef)
+ struct Found_impl : euml_event<Found_impl>,FoundDef
+ {
+ Found_impl(){}
+ Found_impl (const string& data)
+ {
+ get_attribute(m_song)=data;
+ }
+ int foo()const {std::cout << "foo()" << std::endl; return 0;}
+ int foo(int i)const {std::cout << "foo(int):" << i << std::endl; return 1;}
+ int foo(int i,int j)const {std::cout << "foo(int,int):" << i <<"," << j << std::endl; return 2;}
+
+ };
+ Found_impl const Found;
+ // some functions to call
+ // this macro creates a functor and an eUML function wrapper. Now, foo_ can be used anywhere
+ BOOST_MSM_EUML_METHOD(FoundFoo_ , foo , foo_ , int , int )
+
+ template <class T>
+ int do_print(T& t ) {std::cout << "print(T):" << typeid(T).name() << std::endl;return 1;}
+ BOOST_MSM_EUML_FUNCTION(PrintState_ , do_print , print_ , int , int )
+
+ BOOST_MSM_EUML_EVENT(Done)
+
+ // Concrete FSM implementation
+ struct some_base
+ {
+ int foobar()const {std::cout << "foobar()" << std::endl; return 0;}
+ int foobar(int i)const {std::cout << "foobar(int):" << i << std::endl; return 1;}
+ int foobar(int i,int j)const {std::cout << "foobar(int,int):" << i <<"," << j << std::endl; return 2;}
+ };
+ // some functions to call
+ BOOST_MSM_EUML_METHOD(FooBar_ , foobar , foobar_ , int , int )
+
+ // fsm attributes
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(vector<OneSong_impl>,m_src_container)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(list<OneSong_impl>,m_tgt_container)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(list<int>,m_var2)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(list<int>,m_var3)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(set<int>,m_var4)
+ typedef std::map<int,int> int_int_map;
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int_int_map,m_var5)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,m_var6)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,m_var7)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(vector<int>,m_var8)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(vector<int>,m_var9)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int,m_var10)
+
+ // The list of FSM states
+ BOOST_MSM_EUML_STATE(( ( insert_(fsm_(m_tgt_container),end_(fsm_(m_tgt_container)),
+ append_(event_(m_song),fsm_(m_var7)) ),//foo_(event_,Int_<0>()) ,
+ //foo_(event_,Int_<0>(),Int_<1>()),print_(state_),
+ process_(Done/*,fsm_*/),if_then_(true_,true_) ),
+ no_action
+ ),Insert)
+
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,m_letters)
+ BOOST_MSM_EUML_STATE(( if_then_else_( (string_find_(event_(m_song),state_(m_letters),Size_t_<0>()) != Npos_<string>()&&
+ string_find_(event_(m_song),Char_<'S'>(),Size_t_<0>()) != Npos_<string>()&&
+ string_find_first_of_(event_(m_song),Char_<'S'>()) == Size_t_<0>() &&
+ string_compare_(event_(m_song),Int_<0>(),size_(event_(m_song)),event_(m_song)) == Int_<0>()
+ //&& is_flag_(SomeFlag(),fsm_())
+ //&& ( event_(m_song_id) == Int_<1>())
+ //&& string_find_(event_(m_song),String_<mpl::string<'Sh','e'> >())
+ // != Npos_<string>()
+
+ ),
+ process2_(Found,
+ //string_insert_(event_(m_song),Size_t_<0>(),fsm_(m_var6)) ),
+ string_replace_(
+ string_assign_(
+ string_erase_(
+ string_insert_(
+ substr_(event_(m_song),Size_t_<1>()),
+ Size_t_<0>(),
+ Size_t_<1>(),
+ Char_<'S'>()),
+ Size_t_<0>(),
+ Size_t_<1>() ),
+ event_(m_song) ),
+ Size_t_<0>(),
+ Size_t_<1>(),
+ c_str_(fsm_(m_var6))
+ /*Size_t_<1>(),
+ Char_<'s'>()*/ ) ),
+ process2_(NotFound,event_(m_song),fsm_) ) ,
+ no_action,
+ attributes_ << m_letters,
+ configure_<< SomeFlag ),StringFind)
+
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(vector<OneSong_impl>::iterator,m_src_it)
+ BOOST_MSM_EUML_STATE(( if_then_( (state_(m_src_it) != end_(fsm_(m_src_container)) &&
+ //associative_find_(fsm_(m_var4),Int_<9>()) != end_(fsm_(m_var4))&&
+ //associative_count_(fsm_(m_var4),Int_<9>()) == Size_t_<1>() &&
+ //*associative_upper_bound_(fsm_(m_var4),Int_<8>()) == Int_<9>()&&
+ //*associative_lower_bound_(fsm_(m_var4),Int_<9>()) == Int_<9>() &&
+ //second_(associative_equal_range_(fsm_(m_var4),Int_<8>())) == associative_upper_bound_(fsm_(m_var4),Int_<8>()) &&
+ //first_(associative_equal_range_(fsm_(m_var4),Int_<8>())) == associative_lower_bound_(fsm_(m_var4),Int_<8>())&&
+ //second_(*associative_lower_bound_(fsm_(m_var5),Int_<0>())) == Int_<0>() && //map => pair as return
+ //find_if_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Predicate_<LookFor<8> >()) != end_(fsm_(m_var4))&&
+ //*lower_bound_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>(),Predicate_<std::less<int> >()) == Int_<9>()&&
+ //*upper_bound_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<8>(),Predicate_<std::less<int> >()) == Int_<9>() &&
+ //second_(equal_range_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<8>()))
+ // == upper_bound_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<8>()) &&
+ //first_(equal_range_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>(),Predicate_<std::less<int> >()))
+ // == lower_bound_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>(),Predicate_<std::less<int> >())&&
+ //binary_search_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>(),Predicate_<std::less<int> >())&&
+ //binary_search_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>())&&
+ //count_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>()) == Int_<1>()&&
+ //count_if_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Predicate_<LookFor<9> >()) == Int_<1>()&&
+ //distance_(begin_(fsm_(m_var4)),end_(fsm_(m_var4))) == Int_<2>()&&
+ //*min_element_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Predicate_<std::less<int> >()) == Int_<8>()&&
+ //*max_element_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Predicate_<std::less<int> >()) == Int_<9>()&&
+ //adjacent_find_(begin_(fsm_(m_var4)),end_(fsm_(m_var4))) == end_(fsm_(m_var4))&&
+ //*find_end_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),begin_(fsm_(m_var9)),end_(fsm_(m_var9)))
+ // == Int_<1>()&&
+ //*find_first_of_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),begin_(fsm_(m_var9)),end_(fsm_(m_var9)))
+ // == Int_<1>()&&
+ //equal_(begin_(fsm_(m_var9)),end_(fsm_(m_var9)),begin_(fsm_(m_var8)))&&
+ //*search_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),begin_(fsm_(m_var9)),end_(fsm_(m_var9)))
+ // == Int_<1>()&&
+ //includes_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),begin_(fsm_(m_var9)),end_(fsm_(m_var9)))&&
+ //!lexicographical_compare_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),
+ // begin_(fsm_(m_var9)),end_(fsm_(m_var9)))&&
+ //first_(mismatch_(begin_(fsm_(m_var9)),end_(fsm_(m_var9)),begin_(fsm_(m_var8))))
+ // == end_(fsm_(m_var9)) &&
+ accumulate_(begin_(fsm_(m_var9)),end_(fsm_(m_var9)),Int_<1>(),
+ Predicate_<std::plus<int> >()) == Int_<1>()
+ ),
+ (process2_(OneSong,*(state_(m_src_it)++))/*,foobar_(fsm_,Int_<0>())*/ ) ),
+ no_action,
+ attributes_ << m_src_it
+ , configure_<< SomeFlag ),Foreach)
+
+
+ // replaces the old transition table
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ StringFind == Foreach + OneSong[if_then_else_(true_,true_,true_)],
+ Insert == StringFind + Found / (if_then_(true_,no_action)),
+ Foreach == StringFind + NotFound ,
+ Foreach == Insert + Done
+ // +------------------------------------------------------------------------------+
+ ),transition_table )
+
+ BOOST_MSM_EUML_ACTION(Log_No_Transition)
+ {
+ template <class FSM,class Event>
+ void operator()(Event const& e,FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ // create a state machine "on the fly"
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT
+ init_ << Foreach, // Init
+ //insert_(state_(m_var4),begin_(state_(m_var2)),end_(state_(m_var2))),
+ (insert_(state_(m_var4),Int_<5>()),insert_(state_(m_var4),Int_<6>()),insert_(state_(m_var4),Int_<7>()),
+ insert_(state_(m_var4),Int_<8>()),insert_(state_(m_var4),Int_<9>()),
+ associative_erase_(state_(m_var4),Int_<6>()),associative_erase_(state_(m_var4),begin_(state_(m_var4))),
+ associative_erase_(state_(m_var4),begin_(state_(m_var4)),++begin_(state_(m_var4))),
+ insert_(state_(m_var2),begin_(state_(m_var2)),begin_(state_(m_var3)),end_(state_(m_var3))),
+ state_(m_var5)[Int_<0>()]=Int_<0>(),state_(m_var5)[Int_<1>()]=Int_<1>()
+ ,attribute_(substate_(Foreach,fsm_),m_src_it)
+ = begin_(fsm_(m_src_container))
+ //,fill_(begin_(state_(m_var9)),end_(state_(m_var9)),Int_<0>())
+ //,fill_n_(begin_(state_(m_var9)),Size_t_<2>(),Int_<0>())
+ //,transform_(begin_(state_(m_var4)),end_(state_(m_var4)),begin_(state_(m_var2)),begin_(state_(m_var4)),
+ // Predicate_<std::plus<int> >())
+ //,process_(Done,fsm_(),fsm_)
+ //,process_(Done,fsm_)
+ //,fsm_
+ //,foobar_(state_,Int_<0>(),Int_<1>())
+ //,nth_element_(begin_(state_(m_var9)),++begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,partial_sort_(begin_(state_(m_var9)),end_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,partial_sort_copy_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,list_sort_(state_(m_var2))
+ //,sort_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,inner_product_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),Int_<1>())
+ //,replace_copy_(begin_(state_(m_var4)),end_(state_(m_var4)),begin_(state_(m_var4)),Int_<8>(),Int_<7>())
+ //,replace_copy_if_(begin_(state_(m_var4)),end_(state_(m_var4)),begin_(state_(m_var4)),Predicate_<LookFor<9> >(),Int_<8>())
+ //,replace_(begin_(state_(m_var4)),end_(state_(m_var4)),Int_<8>(),Int_<7>())
+ //,replace_if_(begin_(state_(m_var4)),end_(state_(m_var4)),Predicate_<LookFor<9> >(),Int_<8>())
+ //,adjacent_difference_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)))
+ //,partial_sum_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)))
+ //,inner_product_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),Int_<1>())
+ //,next_permutation_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,prev_permutation_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,set_union_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)))
+ //,inplace_merge_(begin_(state_(m_var9)),end_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,merge_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),end_(state_(m_var9))
+ // ,begin_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,stable_sort_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
+ //,partition_(begin_(state_(m_var2)),end_(state_(m_var2)),Predicate_<LessThan<3> >())
+ //,stable_partition_(begin_(state_(m_var2)),end_(state_(m_var2)),Predicate_<LessThan<3> >())
+ //,rotate_copy_(begin_(state_(m_var2)),++begin_(state_(m_var2)),end_(state_(m_var2)),begin_(state_(m_var2)))
+ //,rotate_(begin_(state_(m_var2)),++begin_(state_(m_var2)),end_(state_(m_var2)))
+ //,unique_(begin_(state_(m_var2)),end_(state_(m_var2)))
+ //,unique_copy_(begin_(state_(m_var2)),end_(state_(m_var2)),begin_(state_(m_var2)))
+ //,random_shuffle_(begin_(state_(m_var9)),end_(state_(m_var9)))
+ //,generate_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<Generator>())
+ //,generate_n_(begin_(state_(m_var9)),Int_<2>(),Predicate_<Generator>())
+ //,reverse_copy_(begin_(state_(m_var2)),end_(state_(m_var2)),begin_(state_(m_var2)))
+ //erase_(state_(m_src_container),
+ // remove_if_(begin_(state_(m_src_container)),end_(state_(m_src_container)),
+ // Predicate_<RemoveDummy>()),
+ // end_(state_(m_src_container))),
+ //list_remove_(state_(m_var2),Int_<3>()),
+ //remove_copy_if_(begin_(state_(m_var9)),end_(state_(m_var9)),back_inserter_(state_(m_var2)),
+ // Predicate_<LookFor<2> >() )
+ //for_each_(begin_(state_(m_src_container)),end_(state_m_src_container()),
+ // Predicate_<Print>() ),
+ //copy_(begin_(state_(m_var9)),end_(state_(m_var9)),inserter_(state_(m_var2),end_(state_(m_var2)))),
+ //reverse_(begin_(state_(m_var2)),end_(state_(m_var2)))
+ ),
+ //no_action, // Entry
+ //splice_(state_(m_var2),begin_(state_(m_var2)),state_(m_var3),begin_(state_(m_var3)),end_(state_(m_var3))),
+ //(list_remove_(state_(m_var2),Int_<3>()),list_merge_(state_(m_var2),state_(m_var3),Comparator())),//no_action, // Entry
+ no_action, // Exit
+ attributes_ << m_src_container // song list
+ << m_tgt_container // result
+ << m_var2
+ << m_var3
+ << m_var4
+ << m_var5
+ << m_var6
+ << m_var7
+ << m_var8
+ << m_var9
+ << m_var10,
+ configure_<< no_configure_,
+ Log_No_Transition
+ ),iPodSearch_helper)
+
+ struct iPodSearch_ : public iPodSearch_helper, public some_base
+ {
+ };
+
+
+ // choice of back-end
+ typedef msm::back::state_machine<iPodSearch_> iPodSearch;
+
+ void test()
+ {
+ iPodSearch search;
+ // fill our song list
+ //search.get_attribute<m_src_container>().push_back(OneSong("She-Dummy. Remove this one"));
+ search.get_attribute(m_src_container).push_back(OneSong_impl("Let it be"));
+ search.get_attribute(m_src_container).push_back(OneSong_impl("Yellow submarine"));
+ search.get_attribute(m_src_container).push_back(OneSong_impl("Twist and Shout"));
+ search.get_attribute(m_src_container).push_back(OneSong_impl("She Loves You"));
+
+ search.get_attribute(m_var2).push_back(1);
+ search.get_attribute(m_var2).push_back(3);
+ search.get_attribute(m_var2).push_back(4);
+
+ search.get_attribute(m_var3).push_back(2);
+ search.get_attribute(m_var3).push_back(4);
+
+ search.get_attribute(m_var6) = "S";
+ search.get_attribute(m_var7) = "- Some text";
+
+ search.get_attribute(m_var8).push_back(1);
+ search.get_attribute(m_var8).push_back(2);
+ search.get_attribute(m_var8).push_back(3);
+ search.get_attribute(m_var8).push_back(4);
+
+ search.get_attribute(m_var9).push_back(1);
+ search.get_attribute(m_var9).push_back(2);
+
+
+ // look for "She Loves You" using the first letters
+ // BOOST_MSM_EUML_STATE_NAME returns the name of the event type of which StringFind is an instance
+ search.get_state<BOOST_MSM_EUML_STATE_NAME(StringFind)&>().get_attribute(m_letters)="Sh";
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ search.start();
+ // display all the songs
+ for (list<OneSong_impl>::const_iterator it = search.get_attribute(m_tgt_container).begin();
+ it != search.get_attribute(m_tgt_container).end();++it)
+ {
+ cout << "candidate song:" << (*it).get_data() << endl;
+ }
+ for (list<int>::const_iterator iti = search.get_attribute(m_var2).begin();
+ iti != search.get_attribute(m_var2).end();++iti)
+ {
+ cout << "int in attribute m_var2:" << (*iti) << endl;
+ }
+ for (set<int>::const_iterator its = search.get_attribute(m_var4).begin();
+ its != search.get_attribute(m_var4).end();++its)
+ {
+ cout << "int in attribute m_var4:" << (*its) << endl;
+ }
+ cout << "search using more letters" << endl;
+ // look for "She Loves You" using more letters
+ search.get_state<BOOST_MSM_EUML_STATE_NAME(StringFind)&>().get_attribute(m_letters)="She";
+ search.get_attribute(m_tgt_container).clear();
+ search.start();
+ // display all the songs
+ for (list<OneSong_impl>::const_iterator it = search.get_attribute(m_tgt_container).begin();
+ it != search.get_attribute(m_tgt_container).end();++it)
+ {
+ cout << "candidate song:" << (*it).get_data() << endl;
+ }
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/CompositeTutorial.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/CompositeTutorial.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,222 @@
+#include <iostream>
+// back-end
+#include <boost/msm/back/state_machine.hpp>
+//front-end
+#include <boost/msm/front/state_machine_def.hpp>
+
+namespace msm = boost::msm;
+
+namespace // Concrete FSM implementation
+{
+ // events
+ struct play {};
+ struct end_pause {};
+ struct stop {};
+ struct pause {};
+ struct open_close {};
+ struct NextSong {};
+ struct PreviousSong {};
+
+ // A "complicated" event type that carries some data.
+ struct cd_detected
+ {
+ cd_detected(std::string name)
+ : name(name)
+ {}
+
+ std::string name;
+ };
+
+ // front-end: define the FSM structure
+ struct player_ : public msm::front::state_machine_def<player_>
+ {
+ // The list of FSM states
+ struct Empty : public msm::front::state<>
+ {
+ // every (optional) entry/exit methods get the event passed.
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Empty" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Empty" << std::endl;}
+ };
+ struct Open : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Open" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Open" << std::endl;}
+ };
+
+ struct Stopped : public msm::front::state<>
+ {
+ // when stopped, the CD is loaded
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Stopped" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Stopped" << std::endl;}
+ };
+
+ // the player state machine contains a state which is himself a state machine
+ // as you see, no need to declare it anywhere so Playing can be developed separately
+ // by another team in another module. For simplicity I just declare it inside player
+ struct Playing_ : public msm::front::state_machine_def<Playing_>
+ {
+ // when playing, the CD is loaded and we are in either pause or playing (duh)
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Playing" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Playing" << std::endl;}
+
+ // The list of FSM states
+ struct Song1 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: First song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: First Song" << std::endl;}
+
+ };
+ struct Song2 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: Second song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: Second Song" << std::endl;}
+ };
+ struct Song3 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: Third song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: Third Song" << std::endl;}
+ };
+ // the initial state. Must be defined
+ typedef Song1 initial_state;
+ // transition actions
+ void start_next_song(NextSong const&) { std::cout << "Playing::start_next_song\n"; }
+ void start_prev_song(PreviousSong const&) { std::cout << "Playing::start_prev_song\n"; }
+ // guard conditions
+
+ typedef Playing_ pl; // makes transition table cleaner
+ // Transition table for Playing
+ struct transition_table : mpl::vector4<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Song1 , NextSong , Song2 , &pl::start_next_song >,
+ a_row < Song2 , PreviousSong, Song1 , &pl::start_prev_song >,
+ a_row < Song2 , NextSong , Song3 , &pl::start_next_song >,
+ a_row < Song3 , PreviousSong, Song2 , &pl::start_prev_song >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ // back-end
+ typedef msm::back::state_machine<Playing_> Playing;
+
+
+ // state not defining any entry or exit
+ struct Paused : public msm::front::state<>
+ {
+ };
+
+ // the initial state of the player SM. Must be defined
+ typedef Empty initial_state;
+
+ // transition actions
+ void start_playback(play const&) { std::cout << "player::start_playback\n"; }
+ void open_drawer(open_close const&) { std::cout << "player::open_drawer\n"; }
+ void close_drawer(open_close const&) { std::cout << "player::close_drawer\n"; }
+ void store_cd_info(cd_detected const& cd) {std::cout << "player::store_cd_info\n";}
+ void stop_playback(stop const&) { std::cout << "player::stop_playback\n"; }
+ void pause_playback(pause const&) { std::cout << "player::pause_playback\n"; }
+ void resume_playback(end_pause const&) { std::cout << "player::resume_playback\n"; }
+ void stop_and_open(open_close const&) { std::cout << "player::stop_and_open\n"; }
+ void stopped_again(stop const&) {std::cout << "player::stopped_again\n";}
+ // guard conditions
+
+ typedef player_ p; // makes transition table cleaner
+
+ // Transition table for player
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Stopped , play , Playing , &p::start_playback >,
+ a_row < Stopped , open_close , Open , &p::open_drawer >,
+ a_row < Stopped , stop , Stopped , &p::stopped_again >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Open , open_close , Empty , &p::close_drawer >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Empty , open_close , Open , &p::open_drawer >,
+ a_row < Empty , cd_detected , Stopped , &p::store_cd_info >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Playing , stop , Stopped , &p::stop_playback >,
+ a_row < Playing , pause , Paused , &p::pause_playback >,
+ a_row < Playing , open_close , Open , &p::stop_and_open >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Paused , end_pause , Playing , &p::resume_playback >,
+ a_row < Paused , stop , Stopped , &p::stop_playback >,
+ a_row < Paused , open_close , Open , &p::stop_and_open >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+
+ };
+ // Pick a back-end
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Open", "Empty", "Playing", "Paused" };
+
+ void pstate(player const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ player p;
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ p.start();
+ // go to Open, call on_exit on Empty, then action, then on_entry on Open
+ p.process_event(open_close()); pstate(p);
+ p.process_event(open_close()); pstate(p);
+ p.process_event(cd_detected("louie, louie"));
+ p.process_event(play());
+
+ // at this point, Play is active
+ // make transition happen inside it. Player has no idea about this event but it's ok.
+ p.process_event(NextSong());pstate(p); //2nd song active
+ p.process_event(NextSong());pstate(p);//3rd song active
+ p.process_event(PreviousSong());pstate(p);//2nd song active
+
+ p.process_event(pause()); pstate(p);
+ // go back to Playing
+ // as you see, it starts back from the original state
+ p.process_event(end_pause()); pstate(p);
+ p.process_event(pause()); pstate(p);
+ p.process_event(stop()); pstate(p);
+ // event leading to the same state
+ p.process_event(stop()); pstate(p);
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/CompositeTutorialEuml.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/CompositeTutorialEuml.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,172 @@
+#include <vector>
+#include <iostream>
+
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/euml/euml.hpp>
+
+using namespace std;
+using namespace boost::msm::front::euml;
+namespace msm = boost::msm;
+
+// entry/exit/action/guard logging functors
+#include "logging_functors.h"
+
+namespace // Concrete FSM implementation
+{
+ // events
+ BOOST_MSM_EUML_EVENT(play)
+ BOOST_MSM_EUML_EVENT(end_pause)
+ BOOST_MSM_EUML_EVENT(stop)
+ BOOST_MSM_EUML_EVENT(pause)
+ BOOST_MSM_EUML_EVENT(open_close)
+ BOOST_MSM_EUML_EVENT(next_song)
+ BOOST_MSM_EUML_EVENT(previous_song)
+ BOOST_MSM_EUML_EVENT(region2_evt)
+
+ // A "complicated" event type that carries some data.
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,cd_name)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(DiskTypeEnum,cd_type)
+ BOOST_MSM_EUML_ATTRIBUTES((attributes_ << cd_name << cd_type ), cd_detected_attributes)
+ BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(cd_detected,cd_detected_attributes)
+
+ // Concrete FSM implementation
+
+ // The list of FSM states
+ // state not defining any entry or exit
+ BOOST_MSM_EUML_STATE((),Paused)
+ BOOST_MSM_EUML_STATE(( Empty_Entry,Empty_Exit ),Empty)
+ BOOST_MSM_EUML_STATE(( Open_Entry,Open_Exit ),Open)
+ BOOST_MSM_EUML_STATE(( Stopped_Entry,Stopped_Exit ),Stopped)
+
+
+ // Playing is now a state machine itself.
+
+ // It has 5 substates
+ BOOST_MSM_EUML_STATE(( Song1_Entry,Song1_Exit ),Song1)
+ BOOST_MSM_EUML_STATE(( Song2_Entry,Song2_Exit ),Song2)
+ BOOST_MSM_EUML_STATE(( Song3_Entry,Song3_Exit ),Song3)
+ BOOST_MSM_EUML_STATE(( Region2State1_Entry,Region2State1_Exit ),Region2State1)
+ BOOST_MSM_EUML_STATE(( Region2State2_Entry,Region2State2_Exit ),Region2State2)
+
+ // Playing has a transition table
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ // +------------------------------------------------------------------------------+
+ Song2 == Song1 + next_song / start_next_song,
+ Song1 == Song2 + previous_song / start_prev_song,
+ Song3 == Song2 + next_song / start_next_song,
+ Song2 == Song3 + previous_song / start_prev_song,
+ Region2State2 == Region2State1 + region2_evt
+ // +------------------------------------------------------------------------------+
+ ),playing_transition_table )
+
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE( (playing_transition_table, //STT
+ init_ << Song1 << Region2State1 // Init State
+ ),Playing_)
+ // choice of back-end
+ typedef msm::back::state_machine<Playing_> Playing_type;
+ Playing_type const Playing;
+
+ // guard conditions
+ BOOST_MSM_EUML_ACTION(good_disk_format)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ bool operator()(EVT const& evt,FSM&,SourceState& ,TargetState& )
+ {
+ // to test a guard condition, let's say we understand only CDs, not DVD
+ if (evt.get_attribute(cd_type)!=DISK_CD)
+ {
+ std::cout << "wrong disk, sorry" << std::endl;
+ // just for logging, does not block any transition
+ return true;
+ }
+ std::cout << "good disk" << std::endl;
+ return true;
+ }
+ };
+ // replaces the old transition table
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ Playing == Stopped + play / start_playback ,
+ Playing == Paused + end_pause / resume_playback,
+ // +------------------------------------------------------------------------------+
+ Empty == Open + open_close / close_drawer,
+ // +------------------------------------------------------------------------------+
+ Open == Empty + open_close / open_drawer,
+ Open == Paused + open_close / stop_and_open,
+ Open == Stopped + open_close / open_drawer,
+ Open == Playing + open_close / stop_and_open,
+ // +------------------------------------------------------------------------------+
+ Paused == Playing + pause / pause_playback,
+ // +------------------------------------------------------------------------------+
+ Stopped == Playing + stop / stop_playback,
+ Stopped == Paused + stop / stop_playback,
+ Stopped == Empty + cd_detected [good_disk_format &&(event_(cd_type)==Int_<DISK_CD>())]
+ / (store_cd_info,process_(play)),
+ Stopped == Stopped + stop
+ // +------------------------------------------------------------------------------+
+ ),transition_table)
+
+ // create a state machine "on the fly"
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT
+ init_ << Empty, // Init State
+ no_action, // Entry
+ no_action, // Exit
+ attributes_ << no_attributes_, // Attributes
+ configure_ << no_configure_, // configuration
+ Log_No_Transition // no_transition handler
+ ),
+ player_) //fsm name
+
+ // choice of back-end
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Paused", "Open", "Empty", "Playing" };
+ void pstate(player const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ player p;
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ p.start();
+ // note that we write open_close and not open_close(), like usual. Both are possible with eUML, but
+ // you now have less to type.
+ // go to Open, call on_exit on Empty, then action, then on_entry on Open
+ p.process_event(open_close); pstate(p);
+ p.process_event(open_close); pstate(p);
+ // will be rejected, wrong disk type
+ p.process_event(
+ cd_detected("louie, louie",DISK_DVD)); pstate(p);
+ p.process_event(
+ cd_detected("louie, louie",DISK_CD)); pstate(p);
+ // no need to call play() as the previous event does it in its action method
+ //p.process_event(play);
+
+ // make transition happen inside it. Player has no idea about this event but it's ok.
+ p.process_event(next_song);pstate(p); //2nd song active
+ p.process_event(next_song);pstate(p);//3rd song active
+ p.process_event(previous_song);pstate(p);//2nd song active
+
+ // at this point, Play is active
+ p.process_event(pause); pstate(p);
+
+ // go back to Playing
+ p.process_event(end_pause); pstate(p);
+ p.process_event(pause); pstate(p);
+ p.process_event(stop); pstate(p);
+
+ // event leading to the same state
+ // no action method called as none is defined in the transition table
+ p.process_event(stop); pstate(p);
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/DirectEntryEuml.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/DirectEntryEuml.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,375 @@
+#include <vector>
+#include <iostream>
+
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/euml/euml.hpp>
+
+using namespace std;
+using namespace boost::msm::front::euml;
+namespace msm = boost::msm;
+
+
+namespace // Concrete FSM implementation
+{
+ // events
+ BOOST_MSM_EUML_EVENT(event1)
+ BOOST_MSM_EUML_EVENT(event2)
+ BOOST_MSM_EUML_EVENT(event3)
+ BOOST_MSM_EUML_EVENT(event4)
+ BOOST_MSM_EUML_EVENT(event5)
+ // if we need something special, like a template constructor, we cannot use the helper macros
+ struct event6_impl : euml_event<event6_impl>
+ {
+ event6_impl(){}
+ template <class Event>
+ event6_impl(Event const&){}
+ };
+ event6_impl const event6;
+
+ //Sub fsm state definition
+ BOOST_MSM_EUML_ACTION(SubState1_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::SubState1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubState1_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::SubState1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_STATE(( SubState1_Entry,SubState1_Exit ),SubState1)
+
+ BOOST_MSM_EUML_ACTION(SubState1b_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::SubState1b" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubState1b_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::SubState1b" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_STATE(( SubState1b_Entry,SubState1b_Exit ),SubState1b)
+
+ BOOST_MSM_EUML_ACTION(SubState1c_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::SubState1c" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubState1c_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::SubState1c" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_STATE(( SubState1c_Entry,SubState1c_Exit ),SubState1c)
+
+ BOOST_MSM_EUML_ACTION(SubState2_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::SubState2" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubState2_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::SubState2" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE(0,( SubState2_Entry,SubState2_Exit ),SubState2)
+
+ BOOST_MSM_EUML_ACTION(SubState2b_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::SubState2b" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubState2b_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::SubState2b" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE(1,( SubState2b_Entry,SubState2b_Exit ),SubState2b)
+
+ BOOST_MSM_EUML_ACTION(SubState2c_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::SubState2c" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubState2c_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::SubState2c" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE(2,( SubState2c_Entry,SubState2c_Exit ),SubState2c)
+
+ BOOST_MSM_EUML_ACTION(PseudoEntry1_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::PseudoEntry1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(PseudoEntry1_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::PseudoEntry1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ENTRY_STATE(0,( PseudoEntry1_Entry,PseudoEntry1_Exit ),PseudoEntry1)
+
+ BOOST_MSM_EUML_ACTION(SubState3_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::SubState3" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubState3_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::SubState3" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_STATE(( SubState3_Entry,SubState3_Exit ),SubState3)
+
+ BOOST_MSM_EUML_ACTION(SubState3b_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::SubState3b" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubState3b_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::SubState3b" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_STATE(( SubState3b_Entry,SubState3b_Exit ),SubState3b)
+
+ BOOST_MSM_EUML_ACTION(PseudoExit1_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2::PseudoExit1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(PseudoExit1_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2::PseudoExit1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_EXIT_STATE(( event6,PseudoExit1_Entry,PseudoExit1_Exit ),PseudoExit1)
+
+ // actions
+ BOOST_MSM_EUML_ACTION(entry_action)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(FSM& ,EVT const& ,SourceState& ,TargetState& )
+ {
+ cout << "calling entry_action" << endl;
+ }
+ };
+ // SubFsm definition
+ BOOST_MSM_EUML_ACTION(SubFsm2_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SubFsm2" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(SubFsm2_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: SubFsm2" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ // +------------------------------------------------------------------------------+
+ SubState3 == PseudoEntry1 + event4 / entry_action ,
+ SubState1 == SubState2 + event6 ,
+ PseudoExit1 == SubState3 + event5
+ // +------------------------------------------------------------------------------+
+ ), SubFsm2_transition_table)
+
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE( (SubFsm2_transition_table, //STT
+ init_ << SubState1 << SubState1b << SubState1c, // Init State
+ SubFsm2_Entry, // Entry
+ SubFsm2_Exit
+ ),SubFsm2_def)
+ // inherit to add some typedef
+ struct SubFsm2_ : public SubFsm2_def
+ {
+ // these 2 states are not found in the transition table because they are accessed only through
+ // a fork, so we need to create them explicitly
+ typedef mpl::vector<BOOST_MSM_EUML_STATE_NAME(SubState2b),
+ BOOST_MSM_EUML_STATE_NAME(SubState2c)> explicit_creation;
+ };
+
+ // back-end
+ typedef msm::back::state_machine<SubFsm2_> SubFsm2_type;
+ SubFsm2_type const SubFsm2;
+
+ // Fsm state definitions
+ BOOST_MSM_EUML_ACTION(State1_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: State1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State1_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: State1" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_STATE(( State1_Entry,State1_Exit ),State1)
+
+ BOOST_MSM_EUML_ACTION(State2_Entry)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: State2" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_ACTION(State2_Exit)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: State2" << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_STATE(( State2_Entry,State2_Exit ),State2)
+
+ // Fsm definition
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ // +------------------------------------------------------------------------------+
+ SubFsm2 == State1 + event1 ,
+ explicit_(SubFsm2,SubState2) == State1 + event2,
+ (explicit_(SubFsm2,SubState2),
+ explicit_(SubFsm2,SubState2b),
+ explicit_(SubFsm2,SubState2c)) == State1 + event3 ,
+ entry_pt_(SubFsm2,PseudoEntry1) == State1 + event4 ,
+ State1 == SubFsm2 + event1 ,
+ State2 == exit_pt_
+ (SubFsm2,PseudoExit1) + event6
+ // +------------------------------------------------------------------------------+
+ ),transition_table )
+
+
+ BOOST_MSM_EUML_ACTION(Log_No_Transition)
+ {
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const& e,FSM&,STATE& )
+ {
+ std::cout << "no transition in Fsm"
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT
+ init_ << State1, // Init State
+ no_action, // Entry
+ no_action, // Exit
+ attributes_ << no_attributes_, // Attributes
+ configure_ << no_configure_, // configuration
+ Log_No_Transition // no_transition handler
+ ),
+ Fsm_) //fsm name
+
+ //back-end
+ typedef msm::back::state_machine<Fsm_> Fsm;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "State1", "SubFsm2","State2" };
+ void pstate(Fsm const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ Fsm p;
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ p.start();
+ std::cout << "Simply move in and out of the composite, activate init states" << std::endl;
+ p.process_event(event1); pstate(p);
+ p.process_event(event1); pstate(p);
+ std::cout << "Direct entry into SubFsm2::SubState2, then transition to SubState1 and back to State1" << std::endl;
+ p.process_event(event2); pstate(p);
+ p.process_event(event6); pstate(p);
+ p.process_event(event1); pstate(p);
+ std::cout << "processing fork to SubFsm2::SubState2, SubFsm2::SubState2b and SubFsm2::SubState2c" << std::endl;
+ p.process_event(event3); pstate(p);
+ p.process_event(event1); pstate(p);
+ std::cout << "processing entry pseudo state" << std::endl;
+ p.process_event(event4); pstate(p);
+ p.process_event(event1); pstate(p);
+ std::cout << "processing entry + exit pseudo state" << std::endl;
+ p.process_event(event4); pstate(p);
+ std::cout << "using exit pseudo state" << std::endl;
+ p.process_event(event5); pstate(p);
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/DirectEntryTutorial.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/DirectEntryTutorial.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,210 @@
+#include <vector>
+#include <iostream>
+// back-end
+#include <boost/msm/back/state_machine.hpp>
+//front-end
+#include <boost/msm/front/state_machine_def.hpp>
+
+namespace msm = boost::msm;
+
+namespace
+{
+ // events
+ struct event1 {};
+ struct event2 {};
+ struct event3 {};
+ struct event4 {};
+ struct event5 {};
+ struct event6
+ {
+ event6(){}
+ template <class Event>
+ event6(Event const&){}
+ };
+ // front-end: define the FSM structure
+ struct Fsm_ : public msm::front::state_machine_def<Fsm_>
+ {
+ // The list of FSM states
+ struct State1 : public msm::front::state<>
+ {
+ // every (optional) entry/exit methods get the event passed.
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: State1" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State1" << std::endl;}
+ };
+ struct State2 : public msm::front::state<>
+ {
+ // every (optional) entry/exit methods get the event passed.
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: State2" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: State2" << std::endl;}
+ };
+ struct SubFsm2_ : public msm::front::state_machine_def<SubFsm2_>
+ {
+ typedef msm::back::state_machine<SubFsm2_> SubFsm2;
+
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2" << std::endl;}
+
+ struct SubState1 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2::SubState1" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2::SubState1" << std::endl;}
+ };
+ struct SubState1b : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2::SubState1b" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2::SubState1b" << std::endl;}
+ };
+ struct SubState2 : public msm::front::state<> , public msm::front::explicit_entry<0>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2::SubState2" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2::SubState2" << std::endl;}
+ };
+ struct SubState2b : public msm::front::state<> , public msm::front::explicit_entry<1>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2::SubState2b" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2::SubState2b" << std::endl;}
+ };
+ // test with a pseudo entry
+ struct PseudoEntry1 : public msm::front::entry_pseudo_state<0>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2::PseudoEntry1" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2::PseudoEntry1" << std::endl;}
+ };
+ struct SubState3 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2::SubState3" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2::SubState3" << std::endl;}
+ };
+ struct SubState3b : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2::SubState3b" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2::SubState3b" << std::endl;}
+ };
+ struct PseudoExit1 : public msm::front::exit_pseudo_state<event6>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: SubFsm2::PseudoExit1" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: SubFsm2::PseudoExit1" << std::endl;}
+ };
+ // action methods
+ void entry_action(event4 const&)
+ {
+ std::cout << "calling entry_action" << std::endl;
+ }
+ // the initial state. Must be defined
+ typedef mpl::vector<SubState1,SubState1b> initial_state;
+
+ typedef mpl::vector<SubState2b> explicit_creation;
+
+ // Transition table for SubFsm2
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +--------------+-------------+------------+------------------------+----------------------+
+ a_row < PseudoEntry1 , event4 , SubState3 ,&SubFsm2_::entry_action >,
+ _row < SubState2 , event6 , SubState1 >,
+ _row < SubState3 , event5 , PseudoExit1 >
+ // +--------------+-------------+------------+------------------------+----------------------+
+ > {};
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ typedef msm::back::state_machine<SubFsm2_> SubFsm2;
+
+ // the initial state of the player SM. Must be defined
+ typedef State1 initial_state;
+
+ // transition actions
+ // guard conditions
+
+ // Transition table for Fsm
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +---------------------+--------+------------------------------------+-------+--------+
+ _row < State1 , event1 , SubFsm2 >,
+ _row < State1 , event2 , SubFsm2::direct<SubFsm2_::SubState2> >,
+ _row < State1 , event3 , mpl::vector<SubFsm2::direct<SubFsm2_::SubState2>,
+ SubFsm2::direct<SubFsm2_::SubState2b> > >,
+ _row < State1 , event4 , SubFsm2::entry_pt
+ <SubFsm2_::PseudoEntry1> >,
+ // +---------------------+--------+------------------------------------+-------+--------+
+ _row < SubFsm2 , event1 , State1 >,
+ _row < SubFsm2::exit_pt
+ <SubFsm2_::PseudoExit1>, event6 , State2 >
+ // +---------------------+--------+------------------------------------+-------+--------+
+ > {};
+
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ typedef msm::back::state_machine<Fsm_> Fsm;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "State1", "SubFsm2","State2" };
+ void pstate(Fsm const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ Fsm p;
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ p.start();
+ std::cout << "Simply move in and out of the composite, activate init states" << std::endl;
+ p.process_event(event1()); pstate(p);
+ p.process_event(event1()); pstate(p);
+ std::cout << "Direct entry into SubFsm2::SubState2, then transition to SubState1 and back to State1" << std::endl;
+ p.process_event(event2()); pstate(p);
+ p.process_event(event6()); pstate(p);
+ p.process_event(event1()); pstate(p);
+ std::cout << "processing fork to SubFsm2::SubState2 and SubFsm2::SubState2b" << std::endl;
+ p.process_event(event3()); pstate(p);
+ p.process_event(event1()); pstate(p);
+ std::cout << "processing entry pseudo state" << std::endl;
+ p.process_event(event4()); pstate(p);
+ p.process_event(event1()); pstate(p);
+ std::cout << "processing entry + exit pseudo state" << std::endl;
+ p.process_event(event4()); pstate(p);
+ std::cout << "using exit pseudo state" << std::endl;
+ p.process_event(event5()); pstate(p);
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/EumlInternal.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/EumlInternal.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,144 @@
+#include <vector>
+#include <iostream>
+
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/euml/euml.hpp>
+
+using namespace std;
+using namespace boost::msm::front::euml;
+using namespace boost::msm::front;
+namespace msm = boost::msm;
+
+// entry/exit/action/guard logging functors
+#include "logging_functors.h"
+
+namespace // Concrete FSM implementation
+{
+ // events
+ BOOST_MSM_EUML_EVENT(play)
+ BOOST_MSM_EUML_EVENT(end_pause)
+ BOOST_MSM_EUML_EVENT(stop)
+ BOOST_MSM_EUML_EVENT(pause)
+ BOOST_MSM_EUML_EVENT(open_close)
+ BOOST_MSM_EUML_EVENT(internal_event)
+
+ // A "complicated" event type that carries some data.
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,cd_name)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(DiskTypeEnum,cd_type)
+ BOOST_MSM_EUML_ATTRIBUTES((attributes_ << cd_name << cd_type ), cd_detected_attributes)
+ BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(cd_detected,cd_detected_attributes)
+
+ // Concrete FSM implementation
+
+ // The list of FSM states
+ BOOST_MSM_EUML_STATE(( Empty_Entry,Empty_Exit ),Empty)
+ BOOST_MSM_EUML_STATE(( Open_Entry,Open_Exit ),Open)
+ BOOST_MSM_EUML_STATE(( Stopped_Entry,Stopped_Exit ),Stopped)
+ BOOST_MSM_EUML_STATE(( Playing_Entry,Playing_Exit ),Playing)
+ // state not needing any entry or exit
+ BOOST_MSM_EUML_STATE((),Paused)
+
+ // guard conditions
+ BOOST_MSM_EUML_ACTION(good_disk_format)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ bool operator()(EVT const& evt,FSM&,SourceState& ,TargetState& )
+ {
+ // to test a guard condition, let's say we understand only CDs, not DVD
+ if (evt.get_attribute(cd_type)!=DISK_CD)
+ {
+ std::cout << "wrong disk, sorry" << std::endl;
+ // just for logging, does not block any transition
+ return true;
+ }
+ std::cout << "good disk" << std::endl;
+ return true;
+ }
+ };
+ // replaces the old transition table
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ Playing == Stopped + play / start_playback ,
+ Playing == Paused + end_pause / resume_playback,
+ // +------------------------------------------------------------------------------+
+ Empty == Open + open_close / close_drawer,
+ // +------------------------------------------------------------------------------+
+ Open == Empty + open_close / open_drawer,
+ Open == Paused + open_close / stop_and_open,
+ Open == Stopped + open_close / open_drawer,
+ Open == Playing + open_close / stop_and_open,
+ Open + open_close [internal_guard1] / internal_action1,
+ Open + open_close [internal_guard2] / internal_action2,
+ Open + internal_event / internal_action ,
+ // +------------------------------------------------------------------------------+
+ Paused == Playing + pause / pause_playback,
+ // +------------------------------------------------------------------------------+
+ Stopped == Playing + stop / stop_playback,
+ Stopped == Paused + stop / stop_playback,
+ Stopped == Empty + cd_detected [good_disk_format&&
+ (event_(cd_type)==Int_<DISK_CD>())]
+ / (store_cd_info,process_(play)),
+ Stopped == Stopped + stop
+ // +------------------------------------------------------------------------------+
+ ),transition_table)
+
+
+ // create a state machine "on the fly"
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT
+ init_ << Empty, // Init State
+ no_action, // Entry
+ no_action, // Exit
+ attributes_ << no_attributes_, // Attributes
+ configure_ << no_configure_, // configuration
+ Log_No_Transition // no_transition handler
+ ),
+ player_) //fsm name
+ // choice of back-end
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Paused", "Open", "Empty", "Playing" };
+ void pstate(player const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ player p;
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ p.start();
+ // go to Open, call on_exit on Empty, then action, then on_entry on Open
+ p.process_event(open_close); pstate(p);
+ std::cout << "sending internal event (not rejected)" << std::endl;
+ p.process_event(internal_event);
+ std::cout << "sending open_close event. Conflict with internal transitions (rejecting event)" << std::endl;
+ p.process_event(open_close); pstate(p);
+ // will be rejected, wrong disk type
+ p.process_event(
+ cd_detected("louie, louie",DISK_DVD)); pstate(p);
+ p.process_event(
+ cd_detected("louie, louie",DISK_CD)); pstate(p);
+ // no need to call play() as the previous event does it in its action method
+ //p.process_event(play);
+
+ // at this point, Play is active
+ p.process_event(pause); pstate(p);
+ // go back to Playing
+ p.process_event(end_pause); pstate(p);
+ p.process_event(pause); pstate(p);
+ p.process_event(stop); pstate(p);
+ // event leading to the same state
+ // no action method called as none is defined in the transition table
+ p.process_event(stop); pstate(p);
+ // test call to no_transition
+ p.process_event(pause); pstate(p);
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/EumlInternalDistributed.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/EumlInternalDistributed.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,208 @@
+#include <vector>
+#include <iostream>
+
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/euml/euml.hpp>
+
+using namespace std;
+using namespace boost::msm::front::euml;
+using namespace boost::msm::front;
+namespace msm = boost::msm;
+
+// entry/exit/action/guard logging functors
+#include "logging_functors.h"
+
+namespace // Concrete FSM implementation
+{
+ // events
+ // note that unlike the SimpleTutorial, events must derive from euml_event.
+ BOOST_MSM_EUML_EVENT(play)
+ BOOST_MSM_EUML_EVENT(end_pause)
+ BOOST_MSM_EUML_EVENT(stop)
+ BOOST_MSM_EUML_EVENT(pause)
+ BOOST_MSM_EUML_EVENT(open_close)
+ BOOST_MSM_EUML_EVENT(internal_event)
+ BOOST_MSM_EUML_EVENT(next_song)
+ BOOST_MSM_EUML_EVENT(previous_song)
+
+ // A "complicated" event type that carries some data.
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,cd_name)
+ BOOST_MSM_EUML_DECLARE_ATTRIBUTE(DiskTypeEnum,cd_type)
+ BOOST_MSM_EUML_ATTRIBUTES((attributes_ << cd_name << cd_type ), cd_detected_attributes)
+ BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(cd_detected,cd_detected_attributes)
+
+ // Concrete FSM implementation
+
+ // The list of FSM states
+ BOOST_MSM_EUML_STATE(( Empty_Entry,Empty_Exit ),Empty)
+
+ // we just declare a state type but do not create any instance as we want to inherit from this type
+ BOOST_MSM_EUML_DECLARE_STATE((Open_Entry,Open_Exit),Open_def)
+ // derive to be able to add an internal transition table
+ struct Open_impl : public Open_def
+ {
+ BOOST_MSM_EUML_DECLARE_INTERNAL_TRANSITION_TABLE((
+ open_close [internal_guard1] / internal_action1 ,
+ open_close [internal_guard2] / internal_action2 ,
+ internal_event / internal_action
+ ))
+ };
+ // declare an instance for the stt as we are manually declaring a state
+ Open_impl const Open;
+ BOOST_MSM_EUML_STATE(( Stopped_Entry,Stopped_Exit ),Stopped)
+
+ // Playing is a state machine itself.
+ // It has 3 substates
+ BOOST_MSM_EUML_STATE(( Song1_Entry,Song1_Exit ),Song1)
+ BOOST_MSM_EUML_STATE(( Song2_Entry,Song2_Exit ),Song2)
+ BOOST_MSM_EUML_STATE(( Song3_Entry,Song3_Exit ),Song3)
+
+ // Playing has a transition table
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ // +------------------------------------------------------------------------------+
+ Song2 == Song1 + next_song / start_next_song,
+ Song1 == Song2 + previous_song / start_prev_song,
+ Song3 == Song2 + next_song / start_next_song,
+ Song2 == Song3 + previous_song / start_prev_song
+ // +------------------------------------------------------------------------------+
+ ),playing_transition_table )
+
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE( (playing_transition_table, //STT
+ init_ << Song1 // Init State
+ ),Playing_def)
+
+ // some action for the internal transition
+ BOOST_MSM_EUML_ACTION(playing_internal_action)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const&, FSM& ,SourceState& ,TargetState& )
+ {
+ cout << "Playing::internal action" << endl;
+ }
+ };
+ // derive to be able to add an internal transition table
+ struct Playing_ : public Playing_def
+ {
+ BOOST_MSM_EUML_DECLARE_INTERNAL_TRANSITION_TABLE((
+ internal_event / playing_internal_action
+ ))
+ };
+ // choice of back-end
+ typedef msm::back::state_machine<Playing_> Playing_type;
+ Playing_type const Playing;
+
+
+ // state not needing any entry or exit
+ BOOST_MSM_EUML_STATE((),Paused)
+
+ // guard conditions
+ BOOST_MSM_EUML_ACTION(good_disk_format)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ bool operator()(EVT const& evt,FSM&,SourceState& ,TargetState& )
+ {
+ // to test a guard condition, let's say we understand only CDs, not DVD
+ if (evt.get_attribute(cd_type)!=DISK_CD)
+ {
+ std::cout << "wrong disk, sorry" << std::endl;
+ // just for logging, does not block any transition
+ return true;
+ }
+ std::cout << "good disk" << std::endl;
+ return true;
+ }
+ };
+ // replaces the old transition table
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ Stopped + play / start_playback == Playing ,
+ Stopped + open_close / open_drawer == Open ,
+ Stopped + stop == Stopped ,
+ // +------------------------------------------------------------------------------+
+ Open + open_close / close_drawer == Empty ,
+ // +------------------------------------------------------------------------------+
+ Empty + open_close / open_drawer == Open ,
+ Empty + cd_detected
+ [good_disk_format&&(event_(cd_type)==Int_<DISK_CD>())]
+ / (store_cd_info,process_(play))
+ == Stopped ,
+ // +------------------------------------------------------------------------------+
+ Playing + stop / stop_playback == Stopped ,
+ Playing + pause / pause_playback == Paused ,
+ Playing + open_close / stop_and_open == Open ,
+ // +------------------------------------------------------------------------------+
+ Paused + end_pause / resume_playback == Playing ,
+ Paused + stop / stop_playback == Stopped ,
+ Paused + open_close / stop_and_open == Open
+ // +------------------------------------------------------------------------------+
+ ),transition_table)
+
+
+
+ // create a state machine "on the fly"
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT
+ init_ << Empty, // Init State
+ no_action, // Entry
+ no_action, // Exit
+ attributes_ << no_attributes_, // Attributes
+ configure_ << no_configure_, // configuration
+ Log_No_Transition // no_transition handler
+ ),
+ player_) //fsm name
+
+ // choice of back-end
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Open", "Empty", "Playing", "Paused" };
+ void pstate(player const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ player p;
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ p.start();
+ // go to Open, call on_exit on Empty, then action, then on_entry on Open
+ p.process_event(open_close); pstate(p);
+ std::cout << "sending internal event (not rejected)" << std::endl;
+ p.process_event(internal_event);
+ std::cout << "sending open_close event. Conflict with internal transitions (rejecting event)" << std::endl;
+ p.process_event(open_close); pstate(p);
+ // will be rejected, wrong disk type
+ p.process_event(
+ cd_detected("louie, louie",DISK_DVD)); pstate(p);
+ p.process_event(
+ cd_detected("louie, louie",DISK_CD)); pstate(p);
+ // no need to call play as the previous event does it in its action method
+ //p.process_event(play);
+ // at this point, Play is active
+ // make transition happen inside it. Player has no idea about this event but it's ok.
+ p.process_event(next_song);pstate(p); //2nd song active
+ p.process_event(next_song);pstate(p);//3rd song active
+ p.process_event(previous_song);pstate(p);//2nd song active
+ // event handled internally in Playing, without region checking
+ std::cout << "sending internal event (not rejected)" << std::endl;
+ p.process_event(internal_event);
+
+ p.process_event(pause); pstate(p);
+ // go back to Playing
+ p.process_event(end_pause); pstate(p);
+ p.process_event(pause); pstate(p);
+ p.process_event(stop); pstate(p);
+ // event leading to the same state
+ // no action method called as none is defined in the transition table
+ p.process_event(stop); pstate(p);
+ // test call to no_transition
+ p.process_event(pause); pstate(p);
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/EumlSimple.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/EumlSimple.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,215 @@
+// MsmSimple.cpp : Defines the entry point for the console application.
+//
+
+#include "stdafx.h"
+
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/state_machine_def.hpp>
+#include <boost/msm/front/euml/euml.hpp>
+#include <boost/msm/front/euml/stl.hpp>
+
+namespace msm = boost::msm;
+namespace mpl = boost::mpl;
+using namespace boost::msm::front::euml;
+
+#include <iostream>
+#ifdef WIN32
+#include "windows.h"
+#else
+#include <sys/time.h>
+#endif
+
+namespace // Concrete FSM implementation
+{
+ // events
+ BOOST_MSM_EUML_EVENT(play)
+ BOOST_MSM_EUML_EVENT(end_pause)
+ BOOST_MSM_EUML_EVENT(stop)
+ BOOST_MSM_EUML_EVENT(pause)
+ BOOST_MSM_EUML_EVENT(open_close)
+ BOOST_MSM_EUML_EVENT(cd_detected)
+
+ BOOST_MSM_EUML_ACTION(start_playback)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ }
+ };
+ BOOST_MSM_EUML_ACTION(open_drawer)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ }
+ };
+ BOOST_MSM_EUML_ACTION(close_drawer)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ }
+ };
+ BOOST_MSM_EUML_ACTION(store_cd_info)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const&, FSM& fsm ,SourceState& ,TargetState& )
+ {
+ }
+ };
+ BOOST_MSM_EUML_ACTION(stop_playback)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ }
+ };
+ BOOST_MSM_EUML_ACTION(pause_playback)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ }
+ };
+ BOOST_MSM_EUML_ACTION(resume_playback)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ }
+ };
+ BOOST_MSM_EUML_ACTION(stop_and_open)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ }
+ };
+ BOOST_MSM_EUML_ACTION(stopped_again)
+ {
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
+ {
+ }
+ };
+
+ // The list of FSM states
+ BOOST_MSM_EUML_STATE((),Empty)
+ BOOST_MSM_EUML_STATE((),Open)
+ BOOST_MSM_EUML_STATE((),Stopped)
+ BOOST_MSM_EUML_STATE((),Playing)
+ BOOST_MSM_EUML_STATE((),Paused)
+
+ // replaces the old transition table
+ BOOST_MSM_EUML_TRANSITION_TABLE((
+ Playing == Stopped + play / start_playback ,
+ Playing == Paused + end_pause / resume_playback ,
+ // +------------------------------------------------------------------------------+
+ Empty == Open + open_close / close_drawer ,
+ // +------------------------------------------------------------------------------+
+ Open == Empty + open_close / open_drawer ,
+ Open == Paused + open_close / stop_and_open ,
+ Open == Stopped + open_close / open_drawer ,
+ Open == Playing + open_close / stop_and_open ,
+ // +------------------------------------------------------------------------------+
+ Paused == Playing + pause / pause_playback ,
+ // +------------------------------------------------------------------------------+
+ Stopped == Playing + stop / stop_playback ,
+ Stopped == Paused + stop / stop_playback ,
+ Stopped == Empty + cd_detected / store_cd_info ,
+ Stopped == Stopped + stop / stopped_again
+ // +------------------------------------------------------------------------------+
+ ),transition_table)
+
+ BOOST_MSM_EUML_ACTION(Log_No_Transition)
+ {
+ template <class FSM,class Event>
+ void operator()(Event const& e,FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+
+ // create a state machine "on the fly"
+ BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT
+ init_ << Empty, // Init State
+ no_action, // Entry
+ no_action, // Exit
+ attributes_ << no_attributes_, // Attributes
+ configure_ << no_exception << no_msg_queue, // configuration
+ Log_No_Transition // no_transition handler
+ ),
+ player_) //fsm name
+
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Open", "Empty", "Playing", "Paused" };
+
+ void pstate(player const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+}
+
+#ifndef WIN32
+long mtime(struct timeval& tv1,struct timeval& tv2)
+{
+ return (tv2.tv_sec-tv1.tv_sec) *1000000 + ((tv2.tv_usec-tv1.tv_usec));
+}
+#endif
+
+
+int main()
+{
+ // for timing
+#ifdef WIN32
+ LARGE_INTEGER res;
+ ::QueryPerformanceFrequency(&res);
+ LARGE_INTEGER li,li2;
+#else
+ struct timeval tv1,tv2;
+ gettimeofday(&tv1,NULL);
+#endif
+
+ player p2;
+ p2.start();
+ // for timing
+#ifdef WIN32
+ ::QueryPerformanceCounter(&li);
+#else
+ gettimeofday(&tv1,NULL);
+#endif
+ for (int i=0;i<100;++i)
+ {
+ p2.process_event(open_close);
+ p2.process_event(open_close);
+ p2.process_event(cd_detected);
+ p2.process_event(play);
+ p2.process_event(pause);
+ // go back to Playing
+ p2.process_event(end_pause);
+ p2.process_event(pause);
+ p2.process_event(stop);
+ // event leading to the same state
+ p2.process_event(stop);
+ p2.process_event(open_close);
+ p2.process_event(open_close);
+ }
+#ifdef WIN32
+ ::QueryPerformanceCounter(&li2);
+#else
+ gettimeofday(&tv2,NULL);
+#endif
+#ifdef WIN32
+ std::cout << "msm took in s:" << (double)(li2.QuadPart-li.QuadPart)/res.QuadPart <<"\n" <<std::endl;
+#else
+ std::cout << "msm took in us:" << mtime(tv1,tv2) <<"\n" <<std::endl;
+#endif
+ return 0;
+}
+

Added: sandbox/msm/libs/msm/doc/HTML/examples/Flags.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/Flags.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,243 @@
+#include <iostream>
+// back-end
+#include <boost/msm/back/state_machine.hpp>
+//front-end
+#include <boost/msm/front/state_machine_def.hpp>
+
+namespace msm = boost::msm;
+
+namespace // Concrete FSM implementation
+{
+ // events
+ struct play {};
+ struct end_pause {};
+ struct stop {};
+ struct pause {};
+ struct open_close {};
+ struct NextSong {};
+ struct PreviousSong {};
+
+ // Flags. Allow information about a property of the current state
+ struct PlayingPaused{};
+ struct CDLoaded {};
+ struct FirstSongPlaying {};
+
+ // A "complicated" event type that carries some data.
+ struct cd_detected
+ {
+ cd_detected(std::string name)
+ : name(name)
+ {}
+
+ std::string name;
+ };
+
+ // front-end: define the FSM structure
+ struct player_ : public msm::front::state_machine_def<player_>
+ {
+ // The list of FSM states
+ struct Empty : public msm::front::state<>
+ {
+ // every (optional) entry/exit methods get the event passed.
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Empty" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Empty" << std::endl;}
+ };
+ struct Open : public msm::front::state<>
+ {
+ typedef mpl::vector1<CDLoaded> flag_list;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Open" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Open" << std::endl;}
+ };
+
+ struct Stopped : public msm::front::state<>
+ {
+ // when stopped, the CD is loaded
+ typedef mpl::vector1<CDLoaded> flag_list;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Stopped" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Stopped" << std::endl;}
+ };
+
+ // the player state machine contains a state which is himself a state machine
+ // as you see, no need to declare it anywhere so Playing can be developed separately
+ // by another team in another module. For simplicity I just declare it inside player
+ struct Playing_ : public msm::front::state_machine_def<Playing_>
+ {
+ // when playing, the CD is loaded and we are in either pause or playing (duh)
+ typedef mpl::vector2<PlayingPaused,CDLoaded> flag_list;
+
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "entering: Playing" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "leaving: Playing" << std::endl;}
+
+ // The list of FSM states
+ struct Song1 : public msm::front::state<>
+ {
+ typedef mpl::vector1<FirstSongPlaying> flag_list;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: First song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: First Song" << std::endl;}
+
+ };
+ struct Song2 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: Second song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: Second Song" << std::endl;}
+ };
+ struct Song3 : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: Third song" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: Third Song" << std::endl;}
+ };
+ // the initial state. Must be defined
+ typedef Song1 initial_state;
+ // transition actions
+ void start_next_song(NextSong const&) { std::cout << "Playing::start_next_song\n"; }
+ void start_prev_song(PreviousSong const&) { std::cout << "Playing::start_prev_song\n"; }
+ // guard conditions
+
+ typedef Playing_ pl; // makes transition table cleaner
+ // Transition table for Playing
+ struct transition_table : mpl::vector4<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Song1 , NextSong , Song2 , &pl::start_next_song >,
+ a_row < Song2 , PreviousSong, Song1 , &pl::start_prev_song >,
+ a_row < Song2 , NextSong , Song3 , &pl::start_next_song >,
+ a_row < Song3 , PreviousSong, Song2 , &pl::start_prev_song >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ // back-end
+ typedef msm::back::state_machine<Playing_> Playing;
+
+ // state not defining any entry or exit
+ struct Paused : public msm::front::state<>
+ {
+ typedef mpl::vector2<PlayingPaused,CDLoaded> flag_list;
+ };
+
+ // the initial state of the player SM. Must be defined
+ typedef Empty initial_state;
+
+ // transition actions
+ void start_playback(play const&) { std::cout << "player::start_playback\n"; }
+ void open_drawer(open_close const&) { std::cout << "player::open_drawer\n"; }
+ void close_drawer(open_close const&) { std::cout << "player::close_drawer\n"; }
+ void store_cd_info(cd_detected const& cd) {std::cout << "player::store_cd_info\n";}
+ void stop_playback(stop const&) { std::cout << "player::stop_playback\n"; }
+ void pause_playback(pause const&) { std::cout << "player::pause_playback\n"; }
+ void resume_playback(end_pause const&) { std::cout << "player::resume_playback\n"; }
+ void stop_and_open(open_close const&) { std::cout << "player::stop_and_open\n"; }
+ void stopped_again(stop const&) {std::cout << "player::stopped_again\n";}
+ // guard conditions
+
+ typedef player_ p; // makes transition table cleaner
+
+ // Transition table for player
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Stopped , play , Playing , &p::start_playback >,
+ a_row < Stopped , open_close , Open , &p::open_drawer >,
+ a_row < Stopped , stop , Stopped , &p::stopped_again >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Open , open_close , Empty , &p::close_drawer >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Empty , open_close , Open , &p::open_drawer >,
+ a_row < Empty , cd_detected , Stopped , &p::store_cd_info >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Playing , stop , Stopped , &p::stop_playback >,
+ a_row < Playing , pause , Paused , &p::pause_playback >,
+ a_row < Playing , open_close , Open , &p::stop_and_open >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Paused , end_pause , Playing , &p::resume_playback >,
+ a_row < Paused , stop , Stopped , &p::stop_playback >,
+ a_row < Paused , open_close , Open , &p::stop_and_open >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ // Pick a back-end
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Open", "Empty", "Playing", "Paused" };
+
+ void pstate(player const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+ void test()
+ {
+ player p;
+
+ // needed to start the highest-level SM. This will call on_entry and mark the start of the SM
+ p.start();
+ // tests some flags
+ std::cout << "CDLoaded active:" << std::boolalpha << p.is_flag_active<CDLoaded>() << std::endl; //=> false (no CD yet)
+ // go to Open, call on_exit on Empty, then action, then on_entry on Open
+ p.process_event(open_close()); pstate(p);
+ p.process_event(open_close()); pstate(p);
+ p.process_event(cd_detected("louie, louie"));
+ p.process_event(play());
+
+ // at this point, Play is active
+ std::cout << "PlayingPaused active:" << std::boolalpha << p.is_flag_active<PlayingPaused>() << std::endl;//=> true
+ std::cout << "FirstSong active:" << std::boolalpha << p.is_flag_active<FirstSongPlaying>() << std::endl;//=> true
+
+ // make transition happen inside it. Player has no idea about this event but it's ok.
+ p.process_event(NextSong());pstate(p); //2nd song active
+ p.process_event(NextSong());pstate(p);//3rd song active
+ p.process_event(PreviousSong());pstate(p);//2nd song active
+ std::cout << "FirstSong active:" << std::boolalpha << p.is_flag_active<FirstSongPlaying>() << std::endl;//=> false
+
+ std::cout << "PlayingPaused active:" << std::boolalpha << p.is_flag_active<PlayingPaused>() << std::endl;//=> true
+ p.process_event(pause()); pstate(p);
+ std::cout << "PlayingPaused active:" << std::boolalpha << p.is_flag_active<PlayingPaused>() << std::endl;//=> true
+ // go back to Playing
+ // as you see, it starts back from the original state
+ p.process_event(end_pause()); pstate(p);
+ p.process_event(pause()); pstate(p);
+ p.process_event(stop()); pstate(p);
+ std::cout << "PlayingPaused active:" << std::boolalpha << p.is_flag_active<PlayingPaused>() << std::endl;//=> false
+ std::cout << "CDLoaded active:" << std::boolalpha << p.is_flag_active<CDLoaded>() << std::endl;//=> true
+
+ // event leading to the same state
+ p.process_event(stop()); pstate(p);
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}

Added: sandbox/msm/libs/msm/doc/HTML/examples/MsmComposite.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/MsmComposite.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,236 @@
+// MsmSimple.cpp : Defines the entry point for the console application.
+//
+
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/state_machine_def.hpp>
+
+namespace msm = boost::msm;
+namespace mpl = boost::mpl;
+
+#include <iostream>
+#ifdef WIN32
+#include "windows.h"
+#else
+#include <sys/time.h>
+#endif
+
+namespace test_fsm // Concrete FSM implementation
+{
+ // events
+ struct play {};
+ struct end_pause {};
+ struct stop {};
+ struct pause {};
+ struct open_close {};
+ struct cd_detected{};
+ struct NextSong {};
+ struct PreviousSong {};
+
+
+ // Concrete FSM implementation
+ struct player_ : public msm::front::state_machine_def<player_>
+ {
+ // no need for exception handling or message queue
+ typedef int no_exception_thrown;
+ typedef int no_message_queue;
+
+ // The list of FSM states
+ struct Empty : public msm::front::state<>
+ {
+ // optional entry/exit methods
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Empty" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Empty" << std::endl;*/}
+ };
+ struct Open : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Open" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Open" << std::endl;*/}
+ };
+
+ struct Stopped : public msm::front::state<>
+ {
+ // when stopped, the CD is loaded
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Stopped" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Stopped" << std::endl;*/}
+ };
+
+ struct Playing_ : public msm::front::state_machine_def<Playing_>
+ {
+ // no need for exception handling or message queue
+ typedef int no_exception_thrown;
+ typedef int no_message_queue;
+
+ // The list of FSM states
+ struct Song1 : public msm::front::state<> {};
+ struct Song2 : public msm::front::state<> {};
+ struct Song3 : public msm::front::state<> {};
+ // the initial state. Must be defined
+ typedef Song1 initial_state;
+ // transition actions
+ void start_next_song(NextSong const&) { /*std::cout << "Playing::start_next_song\n";*/ }
+ void start_prev_song(PreviousSong const&) { /*std::cout << "Playing::start_prev_song\n"; */}
+ // guard conditions
+
+ typedef Playing_ pl; // makes transition table cleaner
+ // Transition table for Playing
+ struct transition_table : mpl::vector4<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Song1 , NextSong , Song2 , &pl::start_next_song >,
+ a_row < Song2 , PreviousSong, Song1 , &pl::start_prev_song >,
+ a_row < Song2 , NextSong , Song3 , &pl::start_next_song >,
+ a_row < Song3 , PreviousSong, Song2 , &pl::start_prev_song >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ typedef msm::back::state_machine<Playing_> Playing;
+
+ // state not defining any entry or exit
+ struct Paused : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Paused" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Paused" << std::endl;*/}
+ };
+
+ // the initial state of the player SM. Must be defined
+ typedef Empty initial_state;
+
+ // transition actions
+ void start_playback(play const&) { }
+ void open_drawer(open_close const&) { }
+ void close_drawer(open_close const&) { }
+ void store_cd_info(cd_detected const& cd) { }
+ void stop_playback(stop const&) { }
+ void pause_playback(pause const&) { }
+ void resume_playback(end_pause const&) { }
+ void stop_and_open(open_close const&) { }
+ void stopped_again(stop const&) {}
+ // guard conditions
+
+ typedef player_ p; // makes transition table cleaner
+
+ // Transition table for player
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Stopped , play , Playing , &p::start_playback >,
+ a_row < Stopped , open_close , Open , &p::open_drawer >,
+ a_row < Stopped , stop , Stopped , &p::stopped_again >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Open , open_close , Empty , &p::close_drawer >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Empty , open_close , Open , &p::open_drawer >,
+ a_row < Empty , cd_detected , Stopped , &p::store_cd_info >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Playing , stop , Stopped , &p::stop_playback >,
+ a_row < Playing , pause , Paused , &p::pause_playback >,
+ a_row < Playing , open_close , Open , &p::stop_and_open >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Paused , end_pause , Playing , &p::resume_playback >,
+ a_row < Paused , stop , Stopped , &p::stop_playback >,
+ a_row < Paused , open_close , Open , &p::stop_and_open >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Open", "Empty", "Playing", "Paused" };
+
+ void pstate(player const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+}
+
+#ifndef WIN32
+long mtime(struct timeval& tv1,struct timeval& tv2)
+{
+ return (tv2.tv_sec-tv1.tv_sec) *1000000 + ((tv2.tv_usec-tv1.tv_usec));
+}
+#endif
+
+
+int main()
+{
+ // for timing
+#ifdef WIN32
+ LARGE_INTEGER res;
+ ::QueryPerformanceFrequency(&res);
+ LARGE_INTEGER li,li2;
+#else
+ struct timeval tv1,tv2;
+ gettimeofday(&tv1,NULL);
+#endif
+
+ test_fsm::player p2;
+ p2.start();
+ // for timing
+#ifdef WIN32
+ ::QueryPerformanceCounter(&li);
+#else
+ gettimeofday(&tv1,NULL);
+#endif
+ for (int i=0;i<100;++i)
+ {
+ p2.process_event(test_fsm::open_close());
+ p2.process_event(test_fsm::open_close());
+ p2.process_event(test_fsm::cd_detected());
+ p2.process_event(test_fsm::play());
+ for (int j=0;j<100;++j)
+ {
+ p2.process_event(test_fsm::NextSong());
+ p2.process_event(test_fsm::NextSong());
+ p2.process_event(test_fsm::PreviousSong());
+ p2.process_event(test_fsm::PreviousSong());
+ }
+
+ p2.process_event(test_fsm::pause());
+ // go back to Playing
+ p2.process_event(test_fsm::end_pause());
+ p2.process_event(test_fsm::pause());
+ p2.process_event(test_fsm::stop());
+ // event leading to the same state
+ p2.process_event(test_fsm::stop());
+ p2.process_event(test_fsm::open_close());
+ p2.process_event(test_fsm::open_close());
+ }
+#ifdef WIN32
+ ::QueryPerformanceCounter(&li2);
+#else
+ gettimeofday(&tv2,NULL);
+#endif
+#ifdef WIN32
+ std::cout << "msm took in s:" << (double)(li2.QuadPart-li.QuadPart)/res.QuadPart <<"\n" <<std::endl;
+#else
+ std::cout << "msm took in us:" << mtime(tv1,tv2) <<"\n" <<std::endl;
+#endif
+ return 0;
+}
+

Added: sandbox/msm/libs/msm/doc/HTML/examples/MsmSimple.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/HTML/examples/MsmSimple.cpp 2010-04-05 08:14:04 EDT (Mon, 05 Apr 2010)
@@ -0,0 +1,192 @@
+// MsmSimple.cpp : Defines the entry point for the console application.
+//
+
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/state_machine_def.hpp>
+
+namespace msm = boost::msm;
+namespace mpl = boost::mpl;
+
+#include <iostream>
+#ifdef WIN32
+#include "windows.h"
+#else
+#include <sys/time.h>
+#endif
+
+namespace test_fsm // Concrete FSM implementation
+{
+ // events
+ struct play {};
+ struct end_pause {};
+ struct stop {};
+ struct pause {};
+ struct open_close {};
+ struct cd_detected{};
+
+ // Concrete FSM implementation
+ struct player_ : public msm::front::state_machine_def<player_>
+ {
+ // no need for exception handling or message queue
+ typedef int no_exception_thrown;
+ typedef int no_message_queue;
+
+ // The list of FSM states
+ struct Empty : public msm::front::state<>
+ {
+ // optional entry/exit methods
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Empty" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Empty" << std::endl;*/}
+ };
+ struct Open : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Open" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Open" << std::endl;*/}
+ };
+
+ struct Stopped : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Stopped" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Stopped" << std::endl;*/}
+ };
+
+ struct Playing : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Playing" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Playing" << std::endl;*/}
+ };
+
+ struct Paused : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {/*std::cout << "entering: Paused" << std::endl;*/}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {/*std::cout << "leaving: Paused" << std::endl;*/}
+ };
+
+ // the initial state of the player SM. Must be defined
+ typedef Empty initial_state;
+ // transition actions
+ void start_playback(play const&) { }
+ void open_drawer(open_close const&) { }
+ void close_drawer(open_close const&) { }
+ void store_cd_info(cd_detected const& cd) { }
+ void stop_playback(stop const&) { }
+ void pause_playback(pause const&) { }
+ void resume_playback(end_pause const&) { }
+ void stop_and_open(open_close const&) { }
+ void stopped_again(stop const&) {}
+ // guard conditions
+
+ typedef player_ p; // makes transition table cleaner
+
+ // Transition table for player
+ struct transition_table : mpl::vector<
+ // Start Event Next Action Guard
+ // +---------+-------------+---------+---------------------+----------------------+
+ _row < Stopped , play , Playing >,
+ _row < Stopped , open_close , Open >,
+ _row < Stopped , stop , Stopped >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ _row < Open , open_close , Empty >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ _row < Empty , open_close , Open >,
+ _row < Empty , cd_detected , Stopped >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ _row < Playing , stop , Stopped >,
+ _row < Playing , pause , Paused >,
+ _row < Playing , open_close , Open >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ _row < Paused , end_pause , Playing >,
+ _row < Paused , stop , Stopped >,
+ _row < Paused , open_close , Open >
+ // +---------+-------------+---------+---------------------+----------------------+
+ > {};
+
+ // Replaces the default no-transition response.
+ template <class FSM,class Event>
+ void no_transition(Event const& e, FSM&,int state)
+ {
+ std::cout << "no transition from state " << state
+ << " on event " << typeid(e).name() << std::endl;
+ }
+ };
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Open", "Empty", "Playing", "Paused" };
+
+ void pstate(player const& p)
+ {
+ std::cout << " -> " << state_names[p.current_state()[0]] << std::endl;
+ }
+
+}
+
+#ifndef WIN32
+long mtime(struct timeval& tv1,struct timeval& tv2)
+{
+ return (tv2.tv_sec-tv1.tv_sec) *1000000 + ((tv2.tv_usec-tv1.tv_usec));
+}
+#endif
+
+
+int main()
+{
+ // for timing
+#ifdef WIN32
+ LARGE_INTEGER res;
+ ::QueryPerformanceFrequency(&res);
+ LARGE_INTEGER li,li2;
+#else
+ struct timeval tv1,tv2;
+ gettimeofday(&tv1,NULL);
+#endif
+
+ test_fsm::player p2;
+ p2.start();
+ // for timing
+#ifdef WIN32
+ ::QueryPerformanceCounter(&li);
+#else
+ gettimeofday(&tv1,NULL);
+#endif
+ for (int i=0;i<100;++i)
+ {
+ p2.process_event(test_fsm::open_close());
+ p2.process_event(test_fsm::open_close());
+ p2.process_event(test_fsm::cd_detected());
+ p2.process_event(test_fsm::play());
+ p2.process_event(test_fsm::pause());
+ // go back to Playing
+ p2.process_event(test_fsm::end_pause());
+ p2.process_event(test_fsm::pause());
+ p2.process_event(test_fsm::stop());
+ // event leading to the same state
+ p2.process_event(test_fsm::stop());
+ p2.process_event(test_fsm::open_close());
+ p2.process_event(test_fsm::open_close());
+ }
+#ifdef WIN32
+ ::QueryPerformanceCounter(&li2);
+#else
+ gettimeofday(&tv2,NULL);
+#endif
+#ifdef WIN32
+ std::cout << "msm to