|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r59646 - sandbox/msm/libs/msm/doc
From: christophe.j.henry_at_[hidden]
Date: 2010-02-11 15:12:29
Author: chenry
Date: 2010-02-11 15:12:29 EST (Thu, 11 Feb 2010)
New Revision: 59646
URL: http://svn.boost.org/trac/boost/changeset/59646
Log:
added more deferred examples
Added:
sandbox/msm/libs/msm/doc/Orthogonal-deferred2.cpp (contents, props changed)
sandbox/msm/libs/msm/doc/OrthogonalDeferredEuml2.cpp (contents, props changed)
Text files modified:
sandbox/msm/libs/msm/doc/Orthogonal-deferred.cpp | 1 -
1 files changed, 0 insertions(+), 1 deletions(-)
Modified: sandbox/msm/libs/msm/doc/Orthogonal-deferred.cpp
==============================================================================
--- sandbox/msm/libs/msm/doc/Orthogonal-deferred.cpp (original)
+++ sandbox/msm/libs/msm/doc/Orthogonal-deferred.cpp 2010-02-11 15:12:29 EST (Thu, 11 Feb 2010)
@@ -231,7 +231,6 @@
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();
// test deferred event
Added: sandbox/msm/libs/msm/doc/Orthogonal-deferred2.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/Orthogonal-deferred2.cpp 2010-02-11 15:12:29 EST (Thu, 11 Feb 2010)
@@ -0,0 +1,292 @@
+#include <iostream>
+// back-end
+#include <boost/msm/back/state_machine.hpp>
+//front-end
+#include <boost/msm/front/state_machine_def.hpp>
+#include <boost/msm/front/functor_row.hpp>
+
+namespace msm = boost::msm;
+using namespace boost::msm::front;
+
+namespace
+{
+ // events
+ struct play {};
+ struct end_pause {};
+ struct stop {};
+ struct pause {};
+ struct open_close {};
+ struct NextSong {};
+ struct PreviousSong {};
+ struct error_found {};
+ struct end_error {};
+
+ // 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_>
+ {
+ // we want deferred events and no state requires deferred events (only the fsm in the
+ // transition table), so the fsm does.
+ typedef int activate_deferred_events;
+ // 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;
+ };
+ 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;}
+ };
+ // this state is also made terminal so that all the events are blocked
+ struct ErrorMode : //public msm::front::terminate_state<> // ErrorMode terminates the state machine
+ public msm::front::interrupt_state<end_error> // ErroMode just interrupts. Will resume if
+ // the event end_error is generated
+ {
+ 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& 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";}
+ 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
+
+ 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 >,
+ Row < Open , play , none , Defer , none >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ a_row < Empty , open_close , Open , &p::open_drawer >,
+ a_row < Empty , cd_detected , Stopped , &p::store_cd_info >,
+ Row < Empty , play , none , Defer , none >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ 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 >,
+ // +---------+-------------+---------+---------------------+----------------------+
+ 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;
+ }
+ };
+ // Pick a back-end
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Open", "Empty", "Playing", "Paused","AllOk","ErrorMode" };
+
+ void pstate(player const& p)
+ {
+ // we have now several active states, which we show
+ 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();
+ // test deferred event
+ // deferred in Empty and Open, will be handled only after event cd_detected
+ p.process_event(play());
+
+ // 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"));
+
+ // at this point, Play is active (was deferred)
+ 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
+ // by default, the flags are OR'ed but you can also use AND. Then the flag must be present in
+ // all of the active states
+ std::cout << "CDLoaded active with AND:" << std::boolalpha << p.is_flag_active<CDLoaded,player::Flag_AND>() << std::endl;//=> false
+
+ // event leading to the same state
+ p.process_event(stop()); pstate(p);
+
+ // event leading to a terminal/interrupt state
+ 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(play());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(play());pstate(p);
+
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}
Added: sandbox/msm/libs/msm/doc/OrthogonalDeferredEuml2.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/OrthogonalDeferredEuml2.cpp 2010-02-11 15:12:29 EST (Thu, 11 Feb 2010)
@@ -0,0 +1,259 @@
+#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
+ struct play : euml_event<play>{};
+ struct end_pause : euml_event<end_pause>{};
+ struct stop : euml_event<stop>{};
+ struct pause : euml_event<pause>{};
+ struct open_close : euml_event<open_close>{};
+ struct next_song : euml_event<next_song>{};
+ struct previous_song : euml_event<previous_song>{};
+ struct end_error : euml_event<end_error> {};
+ struct error_found : euml_event<error_found> {};
+
+ // 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)
+ typedef BOOST_TYPEOF(build_attributes(attributes_ << cd_name << cd_type )) cd_detected_attributes;
+ struct cd_detected : euml_event<cd_detected>,cd_detected_attributes
+ {
+ cd_detected(){}
+ cd_detected(std::string name, DiskTypeEnum diskType)
+ {
+ get_attribute(cd_name)=name;
+ get_attribute(cd_type)=diskType;
+ }
+ };
+
+ // Flags. Allow information about a property of the current state
+ struct PlayingPaused: euml_flag<PlayingPaused>{};
+ struct CDLoaded : euml_flag<CDLoaded>{};
+ struct FirstSongPlaying : euml_flag<FirstSongPlaying>{};
+
+ // Concrete FSM implementation
+
+ // The list of FSM states
+
+ typedef BOOST_TYPEOF(build_state(Empty_Entry(),Empty_Exit(),
+ attributes_ << no_attributes_,
+ configure_ << no_configure_ )) Empty;
+
+ typedef BOOST_TYPEOF(build_state( Open_Entry(),Open_Exit(),
+ attributes_ << no_attributes_,
+ configure_<< CDLoaded() // defer play, flag state with CDLoaded
+ )) Open;
+
+ typedef BOOST_TYPEOF(build_state( Stopped_Entry(),Stopped_Exit(),
+ attributes_ << no_attributes_,
+ configure_<< CDLoaded() )) Stopped; // flag state with CDLoaded
+
+ // state not defining any entry or exit
+ typedef BOOST_TYPEOF(build_state(NoAction(),NoAction(),
+ attributes_ << no_attributes_,
+ // defer play, flag state with CDLoaded and PlayingPaused
+ configure_<< PlayingPaused() << CDLoaded() )) Paused;
+
+ typedef BOOST_TYPEOF(build_state( AllOk_Entry(),AllOk_Exit() )) AllOk;
+
+ // a terminate state
+ //typedef BOOST_TYPEOF(build_terminate_state( ErrorMode_Entry(),ErrorMode_Exit() )) ErrorMode;
+ // or as an interrupt state
+ typedef BOOST_TYPEOF(build_interrupt_state( end_error(),ErrorMode_Entry(),ErrorMode_Exit() )) ErrorMode;
+
+
+ // Playing is now a state machine itself.
+
+ // It has 3 substates
+ typedef BOOST_TYPEOF(build_state( Song1_Entry(),Song1_Exit(),
+ attributes_ << no_attributes_,
+ configure_<< FirstSongPlaying() )) Song1;
+
+ typedef BOOST_TYPEOF(build_state( Song2_Entry(),Song2_Exit() )) Song2;
+
+ typedef BOOST_TYPEOF(build_state( Song3_Entry(),Song3_Exit() )) Song3;
+
+
+ // Playing has a transition table
+ typedef BOOST_TYPEOF(build_stt((
+ // +------------------------------------------------------------------------------+
+ 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;
+
+ // VC9 cannot compile the typedef with build_sm if one is also used for player
+#ifndef BOOST_MSVC
+ // create a state machine "on the fly" for Playing
+ typedef BOOST_TYPEOF(build_sm( playing_transition_table(), //STT
+ init_ << Song1() // Init State
+ )) Playing_;
+#else
+ // but this definition is ok
+ struct Playing_ : public BOOST_TYPEOF(build_sm( playing_transition_table(), //STT
+ init_ << Song1(), // Init State
+ NoAction(), // entry
+ NoAction(), // exit
+ attributes_ << no_attributes_, //attributes
+ configure_<< PlayingPaused() << CDLoaded() //flags
+ ))
+ {
+ };
+#endif
+ // choice of back-end
+ typedef msm::back::state_machine<Playing_> Playing;
+
+ // guard conditions
+ struct good_disk_format : 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
+ typedef BOOST_TYPEOF(build_stt((
+ Playing() == Stopped() + play() / start_playback() ,
+ Playing() == Paused() + end_pause() / resume_playback() ,
+ // +------------------------------------------------------------------------------+
+ Empty() == Open() + open_close() / close_drawer(),
+ Empty() + play() / defer_() ,
+ // +------------------------------------------------------------------------------+
+ 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() + play() / defer_() ,
+ // +------------------------------------------------------------------------------+
+ 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() ,
+ ErrorMode() == AllOk() + error_found() / report_error() ,
+ AllOk() == ErrorMode()+ end_error() / report_end_error()
+ // +------------------------------------------------------------------------------+
+ ) ) ) transition_table;
+
+ // create a state machine "on the fly"
+ typedef BOOST_TYPEOF(build_sm( transition_table(), //STT
+ init_ << Empty() << AllOk(), // Init States
+ NoAction(), // Entry
+ NoAction(), // Exit
+ attributes_ << no_attributes_, // Attributes
+ configure_<< deferred_events(), // Flags, Deferred events, configuration
+ Log_No_Transition() // no_transition handler
+ )) player_;
+ // or simply, if no no_transition handler needed:
+ //typedef BOOST_TYPEOF(build_sm( transition_table(), //STT
+ // Empty(), // Init State
+ // )) player_;
+
+ // choice of back-end
+ typedef msm::back::state_machine<player_> player;
+
+ //
+ // Testing utilities.
+ //
+ static char const* const state_names[] = { "Stopped", "Paused", "Open", "Empty", "Playing","AllOk","ErrorMode" };
+ void pstate(player const& p)
+ {
+ // we have now several active states, which we show
+ 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();
+
+ // 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);
+ // 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
+ 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(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
+ 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
+
+ // at this point, Play is active
+ p.process_event(pause()); pstate(p);
+ std::cout << "PlayingPaused active:" << std::boolalpha << p.is_flag_active<PlayingPaused>() << std::endl;//=> true
+
+ // go back to Playing
+ 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
+ // by default, the flags are OR'ed but you can also use AND. Then the flag must be present in
+ // all of the active states
+ std::cout << "CDLoaded active with AND:" << std::boolalpha << p.is_flag_active<CDLoaded,player::Flag_AND>() << std::endl;//=> false
+
+ // event leading to the same state
+ // no action method called as none is defined in the transition table
+ p.process_event(stop()); pstate(p);
+
+ // event leading to a terminal/interrupt state
+ 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(play());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(play());pstate(p);
+
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk