Subject: [Boost-commit] svn:boost r58332 - in sandbox/msm/libs/msm/doc: . BoostCon09
From: christophe.j.henry_at_[hidden]
Date: 2009-12-12 19:21:25
Author: chenry
Date: 2009-12-12 19:21:24 EST (Sat, 12 Dec 2009)
New Revision: 58332
URL: http://svn.boost.org/trac/boost/changeset/58332
Log:
added example from BoostCon09
Added:
sandbox/msm/libs/msm/doc/BoostCon09/
sandbox/msm/libs/msm/doc/BoostCon09/MsmSession_Handout.pdf (contents, props changed)
sandbox/msm/libs/msm/doc/BoostCon09/iPod.cpp (contents, props changed)
sandbox/msm/libs/msm/doc/BoostCon09/iPodEuml.cpp (contents, props changed)
sandbox/msm/libs/msm/doc/BoostCon09/ipod_functors.hpp (contents, props changed)
sandbox/msm/libs/msm/doc/BoostCon09/ipod_menu.gif (contents, props changed)
sandbox/msm/libs/msm/doc/BoostCon09/ipod_playing.gif (contents, props changed)
sandbox/msm/libs/msm/doc/BoostCon09/ipod_top.gif (contents, props changed)
Removed:
sandbox/msm/libs/msm/doc/MsmSession_Handout.pdf
Added: sandbox/msm/libs/msm/doc/BoostCon09/MsmSession_Handout.pdf
==============================================================================
Binary file. No diff available.
Added: sandbox/msm/libs/msm/doc/BoostCon09/iPod.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/BoostCon09/iPod.cpp 2009-12-12 19:21:24 EST (Sat, 12 Dec 2009)
@@ -0,0 +1,520 @@
+#include <vector>
+#include <set>
+#include <string>
+#include <iostream>
+#define FUSION_MAX_VECTOR_SIZE 20
+
+#include "boost/mpl/vector/vector50.hpp"
+#include <boost/msm/back/state_machine.hpp>
+#include <boost/msm/front/state_machine_def.hpp>
+
+using namespace std;
+namespace msm = boost::msm;
+
+namespace // Concrete FSM implementation
+{
+ //flags
+ struct MenuActive{};
+ // hardware-generated events
+ struct Hold {};
+ struct NoHold {};
+ struct SouthPressed {};
+ struct SouthReleased {};
+ struct MiddleButton {};
+ struct EastPressed{};
+ struct EastReleased{};
+ struct Off {};
+ struct MenuButton {};
+
+ // internally used events
+ struct PlayPause {};
+ struct EndPlay {};
+ struct CloseMenu
+ {
+ template<class EVENT>
+ CloseMenu(EVENT const &) {}
+ };
+ struct OnOffTimer {};
+ struct MenuMiddleButton {};
+ struct SelectSong {};
+ struct SongFinished {};
+ struct StartSong
+ {
+ StartSong (int song_index):m_Selected(song_index){}
+ int m_Selected;
+ };
+ struct PreviousSong{};
+ struct NextSong{};
+ struct ForwardTimer{};
+ struct PlayingMiddleButton{};
+
+ // Concrete FSM implementation
+ struct iPod_ : public msm::front::state_machine_def<iPod_>
+ {
+ typedef msm::back::state_machine<iPod_> iPod;
+ // The list of FSM states
+ struct NotHolding : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: NotHolding" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: NotHolding" << std::endl;}
+ };
+ struct Holding : public msm::front::interrupt_state<NoHold>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: Holding" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: Holding" << std::endl;}
+ };
+ struct NotPlaying : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: NotPlaying" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: NotPlaying" << std::endl;}
+ };
+ struct NoMenuMode : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: NoMenuMode" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: NoMenuMode" << std::endl;}
+ };
+ struct NoOnOffButton : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: NoOnOffButton" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: NoOnOffButton" << std::endl;}
+ };
+ struct OffDown : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: OffDown, start timer" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: OffDown, end timer" << std::endl;}
+ };
+ struct PlayerOff : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayerOff" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayerOff" << std::endl;}
+ };
+ struct CheckMiddleButton : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: CheckMiddleButton" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: CheckMiddleButton" << std::endl;}
+ };
+ struct PlayingMode_ : public msm::front::state_machine_def<PlayingMode_>
+ {
+ //flags
+ struct NoFastFwd{};
+
+ struct Playing : public msm::front::state<default_base_state,msm::front::sm_ptr>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& )
+ {
+ std::cout << "starting: PlayingMode::Playing" << std::endl;
+ std::cout << "playing song:" << m_fsm->get_current_song() << std::endl;
+ }
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::Playing" << std::endl;}
+ void set_sm_ptr(PlayingMode_* pl)
+ {
+ m_fsm = pl;
+ }
+ private:
+ PlayingMode_* m_fsm;
+ };
+ struct Paused : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayingMode::Paused" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::Paused" << std::endl;}
+ };
+ struct WaitingForNextPrev : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayingMode::WaitingForNextPrev" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::WaitingForNextPrev" << std::endl;}
+ };
+ struct WaitingForEnd : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayingMode::WaitingForEnd" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::WaitingForEnd" << std::endl;}
+ };
+ struct NoForward : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayingMode::NoForward" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::NoForward" << std::endl;}
+ };
+ struct ForwardPressed : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& )
+ {
+ std::cout << "starting: PlayingMode::ForwardPressed," << "start timer" << std::endl;
+ }
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& )
+ {
+ std::cout << "finishing: PlayingMode::ForwardPressed," << "stop timer" << std::endl;
+ }
+ };
+ struct FastForward : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& )
+ {
+ std::cout << "starting: PlayingMode::FastForward," << "start timer" << std::endl;
+ }
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& )
+ {
+ std::cout << "finishing: PlayingMode::FastForward," << "stop timer" << std::endl;
+ }
+ };
+ struct StdDisplay : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayingMode::StdDisplay" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::StdDisplay" << std::endl;}
+ };
+ struct SetPosition : public msm::front::state<>
+ {
+ typedef mpl::vector1<NoFastFwd> flag_list;
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayingMode::SetPosition" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::SetPosition" << std::endl;}
+ };
+ struct SetMark : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayingMode::SetMark" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::SetMark" << std::endl;}
+ };
+ struct PlayingExit : public msm::front::exit_pseudo_state<EndPlay>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayingMode::PlayingExit" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayingMode::PlayingExit" << std::endl;}
+ };
+ // transition action methods
+ template <class EVT>
+ void inc_song_counter(EVT const&)
+ {
+ if (++m_SongIndex <= m_NumberOfSongs )
+ {
+ std::cout << "playing song:" << m_SongIndex << std::endl;
+ }
+ else
+ {
+ // last song => end playing, next play will start at the beginning
+ m_SongIndex = 1;
+ (static_cast<PlayingMode*>(this))->process_event(EndPlay());
+ }
+ }
+ void select_song(StartSong const& evt)
+ {
+ if ((evt.m_Selected>0) && (evt.m_Selected<=m_NumberOfSongs))
+ {
+ m_SongIndex = evt.m_Selected;
+ std::cout << "selecting song:" << m_SongIndex << std::endl;
+ }
+ else
+ {
+ // play current song
+ std::cout << "selecting song:" << m_SongIndex << std::endl;
+ }
+ }
+ void dec_song_counter(PreviousSong const&)
+ {
+ if (--m_SongIndex >0 )
+ {
+ std::cout << "playing song:" << m_SongIndex << std::endl;
+ }
+ else
+ {
+ // before first song => end playing
+ m_SongIndex = 1;
+ (static_cast<PlayingMode*>(this))->process_event(EndPlay());
+ }
+ }
+ void send_NextSong(EastReleased const&)
+ {
+ // event internal to PlayingMode
+ (static_cast<PlayingMode*>(this))->process_event(NextSong());
+ }
+ void do_fast_forward(ForwardTimer const&)
+ {
+ std::cout << "moving song forward..." << std::endl;
+ }
+ /*void stop_timer_100ms(EastReleased const&)
+ {
+
+ }*/
+ // transition guard methods
+ bool fast_fwd_ok(EastPressed const&)
+ {
+ // guard accepts only if fast forward is possible (No SetPosition mode)
+ return !(static_cast<PlayingMode*>(this))->is_flag_active<NoFastFwd>();
+ }
+ // initial states / orthogonal zones
+ typedef mpl::vector5<Playing,WaitingForNextPrev,WaitingForEnd,NoForward,StdDisplay>
+ initial_state;
+ typedef PlayingMode_ fsm; // makes transition table cleaner
+ // Transition table for player
+ struct transition_table : mpl::vector19<
+ // Start Event Next Action Guard
+ // +--------------------+---------------------+--------------------+--------------------------+----------------------+
+ _row < Playing , PlayPause , Paused >,
+ _row < Playing , Off , Paused >,
+ a_row < Playing , StartSong , Playing , &fsm::select_song >,
+ _row < Paused , PlayPause , Playing >,
+ a_row < Playing , SongFinished , Playing , &fsm::inc_song_counter >,
+ a_row < Paused , StartSong , Playing , &fsm::select_song >,
+ // +--------------------+---------------------+--------------------+--------------------------+----------------------+
+ a_row < WaitingForNextPrev , PreviousSong , WaitingForNextPrev , &fsm::dec_song_counter >,
+ a_row < WaitingForNextPrev , NextSong , WaitingForNextPrev , &fsm::inc_song_counter >,
+ // +--------------------+---------------------+--------------------+--------------------------+----------------------+
+ _row < WaitingForEnd , EndPlay , PlayingExit >,
+ // +--------------------+---------------------+--------------------+--------------------------+----------------------+
+ g_row < NoForward , EastPressed , ForwardPressed , &fsm::fast_fwd_ok >,
+ a_row < ForwardPressed , EastReleased , NoForward , &fsm::send_NextSong >,
+ a_row < ForwardPressed , ForwardTimer , FastForward , &fsm::do_fast_forward >,
+ a_row < FastForward , ForwardTimer , FastForward , &fsm::do_fast_forward >,
+ _row < FastForward , EastReleased , NoForward >,
+ // +--------------------+---------------------+---------------------+--------------------------+----------------------+
+ _row < StdDisplay , PlayingMiddleButton , SetPosition >,
+ _row < SetPosition , StartSong , StdDisplay >,
+ _row < SetPosition , PlayingMiddleButton , SetMark >,
+ _row < SetMark , PlayingMiddleButton , StdDisplay >,
+ _row < SetMark , StartSong , StdDisplay >
+ // +--------------------+---------------------+---------------------+--------------------------+----------------------+
+ > {};
+ //a fsm having exit pseudo states need a template constructor calling the one of the basic class
+ //template <class ContainingSM>
+ //PlayingMode_(ContainingSM* sm):
+ // state_machine_<PlayingMode> (sm),
+ // m_SongIndex(1),
+ // // for simplicity we decide there are 5 songs
+ // m_NumberOfSongs(5){}
+
+ PlayingMode_():
+ m_SongIndex(1),
+ // for simplicity we decide there are 5 songs
+ m_NumberOfSongs(5){}
+
+ int get_current_song(){return m_SongIndex;}
+ private:
+ int m_SongIndex;
+ int m_NumberOfSongs;
+
+ };
+ typedef msm::back::state_machine<PlayingMode_> PlayingMode;
+
+ struct MenuMode_ : public msm::front::state_machine_def<MenuMode_>
+ {
+ typedef mpl::vector1<MenuActive> flag_list;
+ struct WaitingForSongChoice : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: MenuMode::WaitingForSongChoice" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: MenuMode::WaitingForSongChoice" << std::endl;}
+ };
+ struct StartCurrentSong : public msm::front::state<>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: MenuMode::StartCurrentSong" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: MenuMode::StartCurrentSong" << std::endl;}
+ };
+ struct MenuExit : public msm::front::exit_pseudo_state<CloseMenu>
+ {
+ template <class Event,class FSM>
+ void on_entry(Event const&,FSM& ) {std::cout << "starting: MenuMode::WaitingForSongChoice" << std::endl;}
+ template <class Event,class FSM>
+ void on_exit(Event const&,FSM& ) {std::cout << "finishing: MenuMode::WaitingForSongChoice" << std::endl;}
+ };
+ typedef WaitingForSongChoice initial_state;
+ typedef MenuMode_ fsm; // makes transition table cleaner
+ // Transition table for player
+ struct transition_table : mpl::vector2<
+ // Start Event Next Action Guard
+ // +---------------------+------------------+-------------------+---------------------+----------------------+
+ _row < WaitingForSongChoice , MenuMiddleButton , StartCurrentSong >,
+ _row < StartCurrentSong , SelectSong , MenuExit >
+ // +---------------------+------------------+-------------------+---------------------+----------------------+
+ > {};
+ //a fsm having exit pseudo states need a template constructor calling the one of the basic class
+ //template <class ContainingSM>
+ //MenuMode_(ContainingSM* sm): state_machine_<MenuMode> (sm){}
+ //MenuMode_(){}
+ };
+ typedef msm::back::state_machine<MenuMode_> MenuMode;
+
+ // the initial state of the player SM. Must be defined
+ typedef mpl::vector5<NotHolding,NotPlaying,NoMenuMode,NoOnOffButton,CheckMiddleButton>
+ initial_state;
+ // transition actions
+ void send_ActivateMenu(EndPlay const&)
+ {
+ // we need to activate the menu and simulate its button
+ (static_cast<iPod*>(this))->process_event(MenuButton());
+ }
+ void send_StartSong(CloseMenu const&)
+ {
+ // we suppose the 5th song was selected
+ (static_cast<iPod*>(this))->process_event(StartSong(5));
+ }
+ void send_PlayPause(SouthReleased const&)
+ {
+ // action using the message queue to generate another event
+ (static_cast<iPod*>(this))->process_event(PlayPause());
+ }
+ void send_Off(OnOffTimer const&)
+ {
+ std::cout << "turning player off" << std::endl;
+ (static_cast<iPod*>(this))->process_event(Off());
+ }
+ void send_PlayingMiddleButton(MiddleButton const&)
+ {
+ (static_cast<iPod*>(this))->process_event(PlayingMiddleButton());
+ }
+ void send_MenuMiddleButton(MiddleButton const&)
+ {
+ (static_cast<iPod*>(this))->process_event(MenuMiddleButton());
+ }
+ // guard conditions
+ bool is_menu(MiddleButton const&)
+ {
+ return (static_cast<iPod*>(this))->is_flag_active<MenuActive>();
+ }
+ bool is_no_menu(MiddleButton const& evt)
+ {
+ return !is_menu(evt);
+ }
+ template <class EVENT>
+ void switch_on(EVENT const&)
+ {
+ std::cout << "turning player on" << std::endl;
+ }
+ typedef iPod_ fsm; // makes transition table cleaner
+
+ // Transition table for player
+ struct transition_table : mpl::vector13<
+ // Start Event Next Action Guard
+ // +-------------------+---------------+-------------------+--------------------------------+----------------------+
+ _row < NotHolding , Hold , Holding >,
+ _row < Holding , NoHold , NotHolding >,
+ // +-------------------+---------------+-------------------+--------------------------------+----------------------+
+ _row < NotPlaying , PlayPause , PlayingMode >,
+ a_row < PlayingMode::exit_pt<PlayingMode_::
+ PlayingExit> , EndPlay , NotPlaying , &fsm::send_ActivateMenu >,
+ // +-------------------+---------------+-------------------+--------------------------------+----------------------+
+ _row < NoMenuMode , MenuButton , MenuMode >,
+ a_row < MenuMode::exit_pt<MenuMode_::
+ MenuExit> , CloseMenu , NoMenuMode , &fsm::send_StartSong >,
+ // +-------------------+---------------+-------------------+--------------------------------+----------------------+
+ _row < NoOnOffButton , SouthPressed , OffDown >,
+ a_row < OffDown , SouthReleased , NoOnOffButton , &fsm::send_PlayPause >,
+ a_row < OffDown , OnOffTimer , PlayerOff , &fsm::send_Off >,
+ a_row < PlayerOff , SouthPressed , NoOnOffButton , &fsm::switch_on >,
+ a_row < PlayerOff , NoHold , NoOnOffButton , &fsm::switch_on >,
+ // +-------------------+---------------+--------------------+--------------------------------+----------------------+
+ row < CheckMiddleButton , MiddleButton , CheckMiddleButton , &fsm::send_PlayingMiddleButton , &fsm::is_menu >,
+ row < CheckMiddleButton , MiddleButton , CheckMiddleButton , &fsm::send_MenuMiddleButton , &fsm::is_no_menu >
+ // +-------------------+---------------+--------------------+--------------------------------+----------------------+
+ > {};
+
+ // 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<iPod_> iPod;
+
+ void test()
+ {
+ iPod sm;
+ sm.start();
+ // we first press Hold
+ std::cout << "pressing hold" << std::endl;
+ sm.process_event(Hold());
+ // pressing a button is now ignored
+ std::cout << "pressing a button" << std::endl;
+ sm.process_event(SouthPressed());
+ // or even one contained in a submachine
+ sm.process_event(EastPressed());
+ // no more holding
+ std::cout << "no more holding, end interrupt event sent" << std::endl;
+ sm.process_event(NoHold());
+ std::cout << "pressing South button a short time" << std::endl;
+ sm.process_event(SouthPressed());
+ // we suppose a short pressing leading to playing a song
+ sm.process_event(SouthReleased());
+ // we move to the next song
+ std::cout << "we move to the next song" << std::endl;
+ sm.process_event(NextSong());
+ // then back to no song => exit from playing, menu active
+ std::cout << "we press twice the West button (simulated)=> end of playing" << std::endl;
+ sm.process_event(PreviousSong());
+ sm.process_event(PreviousSong());
+ // even in menu mode, pressing play will start playing the first song
+ std::cout << "pressing play/pause" << std::endl;
+ sm.process_event(SouthPressed());
+ sm.process_event(SouthReleased());
+ // of course pausing must be possible
+ std::cout << "pressing play/pause" << std::endl;
+ sm.process_event(SouthPressed());
+ sm.process_event(SouthReleased());
+ std::cout << "pressing play/pause" << std::endl;
+ sm.process_event(SouthPressed());
+ sm.process_event(SouthReleased());
+ // while playing, you can fast forward
+ std::cout << "pressing East button a long time" << std::endl;
+ sm.process_event(EastPressed());
+ // let's suppose the timer just fired
+ sm.process_event(ForwardTimer());
+ sm.process_event(ForwardTimer());
+ // end of fast forwarding
+ std::cout << "releasing East button" << std::endl;
+ sm.process_event(EastReleased());
+ // we now press the middle button to set playing at a given position
+ std::cout << "pressing Middle button, fast forwarding disabled" << std::endl;
+ sm.process_event(MiddleButton());
+ std::cout <<"pressing East button to fast forward" << std::endl;
+ sm.process_event(EastPressed());
+ // we switch off and on
+ std::cout <<"switch off player" << std::endl;
+ sm.process_event(SouthPressed());
+ sm.process_event(OnOffTimer());
+ std::cout <<"switch on player" << std::endl;
+ sm.process_event(SouthPressed());
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}
Added: sandbox/msm/libs/msm/doc/BoostCon09/iPodEuml.cpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/BoostCon09/iPodEuml.cpp 2009-12-12 19:21:24 EST (Sat, 12 Dec 2009)
@@ -0,0 +1,302 @@
+#include <vector>
+#include <set>
+#include <string>
+#include <iostream>
+//TODO
+#define FUSION_MAX_VECTOR_SIZE 20
+
+#include "boost/mpl/vector/vector50.hpp"
+#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;
+//attributes
+#define m_SongIndex 0
+#define m_NumberOfSongs 1
+#define m_Selected 0
+#include "ipod_functors.hpp"
+
+
+namespace // Concrete FSM implementation
+{
+ //flags
+ struct MenuActive : euml_flag<MenuActive> {};
+ struct NoFastFwd : euml_flag<NoFastFwd> {};
+ // hardware-generated events
+ struct Hold : euml_event<Hold> {};
+ struct NoHold : euml_event<NoHold> {};
+ struct SouthPressed : euml_event<SouthPressed> {};
+ struct SouthReleased : euml_event<SouthReleased> {};
+ struct MiddleButton : euml_event<MiddleButton> {};
+ struct EastPressed : euml_event<EastPressed> {};
+ struct EastReleased : euml_event<EastReleased>{};
+ struct Off : euml_event<Off> {};
+ struct MenuButton : euml_event<MenuButton> {};
+
+ // internally defined events
+ struct PlayPause : euml_event<PlayPause> {};
+ struct EndPlay : euml_event<EndPlay> {};
+ struct CloseMenu : euml_event<CloseMenu>
+ {
+ CloseMenu(){}//defined only for stt
+ template<class EVENT>
+ CloseMenu(EVENT const &) {}
+ };
+ struct OnOffTimer : euml_event<OnOffTimer> {};
+ struct MenuMiddleButton : euml_event<MenuMiddleButton> {};
+ struct SelectSong : euml_event<SelectSong> {};
+ struct SongFinished : euml_event<SongFinished> {};
+
+ typedef BOOST_TYPEOF(build_attributes(attributes_ << int()/*m_Selected*/ )) StartSongAttributes;
+ struct StartSong : euml_event<StartSong> ,StartSongAttributes
+ {
+ StartSong(){}//defined only for stt
+ StartSong (int song_index)
+ {
+ get_attribute<m_Selected>()=song_index;
+ }
+ };
+ struct PreviousSong : euml_event<PreviousSong> {};
+ struct NextSong : euml_event<NextSong>{};
+ struct ForwardTimer : euml_event<ForwardTimer>{};
+ struct PlayingMiddleButton : euml_event<PlayingMiddleButton>{};
+
+ // Concrete iPod implementation
+ // The list of iPod states
+ typedef BOOST_TYPEOF(build_state(NotHolding_Entry() )) NotHolding;
+ typedef BOOST_TYPEOF(build_interrupt_state(NoHold(),Holding_Entry() )) Holding;
+ typedef BOOST_TYPEOF(build_state(NotPlaying_Entry() )) NotPlaying;
+ typedef BOOST_TYPEOF(build_state(NoMenuMode_Entry() )) NoMenuMode;
+ typedef BOOST_TYPEOF(build_state(NoOnOffButton_Entry() )) NoOnOffButton;
+ typedef BOOST_TYPEOF(build_state(OffDown_Entry() )) OffDown;
+ typedef BOOST_TYPEOF(build_state(PlayerOff_Entry() )) PlayerOff;
+ typedef BOOST_TYPEOF(build_state(CheckMiddleButton_Entry() )) CheckMiddleButton;
+ // Concrete PlayingMode_ implementation
+ // The list of PlayingMode_ states
+ typedef BOOST_TYPEOF(build_state((Playing_Entry()/*,*/ ) )) Playing;
+ typedef BOOST_TYPEOF(build_state(WaitingForNextPrev_Entry() )) WaitingForNextPrev;
+ typedef BOOST_TYPEOF(build_state(Paused_Entry() )) Paused;
+ typedef BOOST_TYPEOF(build_state(WaitingForEnd_Entry() )) WaitingForEnd;
+ typedef BOOST_TYPEOF(build_state(NoForward_Entry() )) NoForward;
+ typedef BOOST_TYPEOF(build_state(ForwardPressed_Entry(),ForwardPressed_Exit() )) ForwardPressed;
+ typedef BOOST_TYPEOF(build_state(FastForward_Entry(),FastForward_Exit() )) FastForward;
+ typedef BOOST_TYPEOF(build_state(StdDisplay_Entry() )) StdDisplay;
+ typedef BOOST_TYPEOF(build_state(SetPosition_Entry() )) SetPosition;
+ typedef BOOST_TYPEOF(build_state(SetMark_Entry() )) SetMark;
+ typedef BOOST_TYPEOF(build_exit_state(EndPlay(),PlayingExit_Entry() )) PlayingExit;
+
+ //stt
+ typedef BOOST_TYPEOF(build_stt((
+ // +------------------------------------------------------------------------------+
+ Playing() + PlayPause() == Paused() ,
+ Playing() + Off() == Paused() ,
+ Playing() + StartSong() == Playing()
+ / (if_then_(Event_<m_Selected>() > Int_<0>() &&
+ Event_<m_Selected>() < Fsm_<m_NumberOfSongs>(),
+ Fsm_<m_SongIndex>() = Event_<m_Selected>() ),show_selected_song()) ,
+ Playing() + SongFinished() == Playing()
+ / (if_then_else_(++Fsm_<m_SongIndex>() <= Fsm_<m_NumberOfSongs>(), /*if*/
+ show_playing_song(), /*then*/
+ (Fsm_<m_SongIndex>()=Int_<1>(),process_(EndPlay()))/*else*/ ) ) ,
+ Paused() + PlayPause() == Playing() ,
+ Paused() + StartSong() == Playing()
+ / (if_then_(Event_<m_Selected>() > Int_<0>() &&
+ Event_<m_Selected>() < Fsm_<m_NumberOfSongs>(),
+ Fsm_<m_SongIndex>() = Event_<m_Selected>() ),show_selected_song()) ,
+ WaitingForNextPrev()+ PreviousSong() == WaitingForNextPrev()
+ /( if_then_else_(--Fsm_<m_SongIndex>() > Int_<0>(), /*if*/
+ show_playing_song(), /*then*/
+ (Fsm_<m_SongIndex>()=Int_<1>(),process_(EndPlay())) /*else*/ ) ) ,
+ WaitingForNextPrev()+ NextSong() == WaitingForNextPrev()
+ / (if_then_else_(++Fsm_<m_SongIndex>() <= Fsm_<m_NumberOfSongs>(), /*if*/
+ show_playing_song(), /*then*/
+ (Fsm_<m_SongIndex>()=Int_<1>(),process_(EndPlay())) /*else*/ ) ) ,
+
+ WaitingForEnd() + EndPlay() == PlayingExit() ,
+ NoForward() + EastPressed() == ForwardPressed() [!is_flag_(NoFastFwd())] ,
+ ForwardPressed() + EastReleased() == NoForward() / process_(NextSong()) ,
+ ForwardPressed() + ForwardTimer() == FastForward() / do_fast_forward() ,
+ FastForward() + ForwardTimer() == FastForward() / do_fast_forward() ,
+ FastForward() + EastReleased() == NoForward() ,
+ StdDisplay() + PlayingMiddleButton() == SetPosition() ,
+ SetPosition() + StartSong() == StdDisplay() ,
+ SetPosition() + PlayingMiddleButton() == SetMark() ,
+ SetMark() + PlayingMiddleButton() == StdDisplay() ,
+ SetMark() + StartSong() == StdDisplay()
+ // +------------------------------------------------------------------------------+
+ ) ) ) playingmode_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( playingmode_transition_table(), //STT
+ init_ << Playing() << WaitingForNextPrev() << WaitingForEnd()
+ << NoForward() << StdDisplay(), // Init States
+ Fsm_<m_NumberOfSongs>()=Int_<5>(), // entry
+ NoAction(), // exit
+ attributes_ << int() /*m_SongIndex*/ << int() /*m_NumberOfSongs*/, //attributes
+ configure_<< NoFastFwd() // Flags, Deferred events, configuration
+
+ )) PlayingMode_;
+#else
+ // but this definition is ok
+ struct PlayingMode_ : public BOOST_TYPEOF(build_sm( playingmode_transition_table(), //STT
+ init_ << Playing() << WaitingForNextPrev() << WaitingForEnd()
+ << NoForward() << StdDisplay(), // Init States
+ Fsm_<m_NumberOfSongs>()=Int_<5>(), // entry
+ NoAction(), // exit
+ attributes_ << int() /*m_SongIndex*/ << int() /*m_NumberOfSongs*/, //attributes
+ configure_<< NoFastFwd() // Flags, Deferred events, configuration
+ ))
+ {
+ };
+#endif
+ // choice of back-end
+ typedef msm::back::state_machine<PlayingMode_> PlayingMode;
+
+ // Concrete MenuMode_ implementation
+ // The list of MenuMode_ states
+ typedef BOOST_TYPEOF(build_state(WaitingForSongChoice_Entry() )) WaitingForSongChoice;
+ typedef BOOST_TYPEOF(build_state(StartCurrentSong_Entry() )) StartCurrentSong;
+ typedef BOOST_TYPEOF(build_exit_state(CloseMenu(),MenuExit_Entry() )) MenuExit;
+ //stt
+ typedef BOOST_TYPEOF(build_stt((
+ // +------------------------------------------------------------------------------+
+ WaitingForSongChoice() + MenuMiddleButton() == StartCurrentSong() ,
+ StartCurrentSong() + SelectSong() == MenuExit()
+ // +------------------------------------------------------------------------------+
+ ) ) ) menumode_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( menumode_transition_table(), //STT
+ init_ << WaitingForSongChoice(), // Init States
+ NoAction(), // entry
+ NoAction(), // exit
+ attributes_ << no_attributes_, //attributes
+ configure_<< MenuActive() // Flags, Deferred events, configuration
+
+ )) MenuMode_;
+#else
+ // but this definition is ok
+ struct MenuMode_ : public BOOST_TYPEOF(build_sm( menumode_transition_table(), //STT
+ init_ << WaitingForSongChoice(), // Init States
+ NoAction(), // entry
+ NoAction(), // exit
+ attributes_ << no_attributes_, //attributes
+ configure_<< MenuActive() // Flags, Deferred events, configuration
+ ))
+ {
+ };
+#endif
+ typedef msm::back::state_machine<MenuMode_> MenuMode;
+
+ // iPod stt
+ typedef BOOST_TYPEOF(build_stt((
+ // +------------------------------------------------------------------------------+
+ NotHolding() + Hold() == Holding() ,
+ Holding() + NoHold() == NotHolding() ,
+ NotPlaying() + PlayPause() == PlayingMode() ,
+ PlayingMode::
+ exit_pt<PlayingExit>() + EndPlay() == NotPlaying() / process_(MenuButton()) ,
+ NoMenuMode() + MenuButton() == MenuMode() ,
+ MenuMode::
+ exit_pt<MenuExit>() + CloseMenu() == NoMenuMode() / process2_(StartSong(),Int_<5>()) ,
+ NoOnOffButton() + SouthPressed() == OffDown() ,
+ OffDown() + SouthReleased() == NoOnOffButton() / process_(PlayPause()) ,
+ OffDown() + OnOffTimer() == PlayerOff() / (show_player_off(),process_(Off())) ,
+ PlayerOff() + SouthPressed() == NoOnOffButton() / show_player_on() ,
+ PlayerOff() + NoHold() == NoOnOffButton() / show_player_on(),
+ CheckMiddleButton() + MiddleButton() == CheckMiddleButton()
+ [is_flag_(MenuActive())] / process_(PlayingMiddleButton()) ,
+ CheckMiddleButton() + MiddleButton() == CheckMiddleButton()
+ [!is_flag_(MenuActive())] / process_(PlayingMiddleButton())
+ // +------------------------------------------------------------------------------+
+ ) ) ) ipod_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( ipod_transition_table(), //STT
+ init_ << NotHolding() << NotPlaying() << NoMenuMode()
+ << NoOnOffButton() << CheckMiddleButton() // Init States
+ )) iPod_;
+#else
+ // but this definition is ok
+ struct iPod_ : public BOOST_TYPEOF(build_sm( ipod_transition_table(), //STT
+ init_ << NotHolding() << NotPlaying() << NoMenuMode()
+ << NoOnOffButton() << CheckMiddleButton() // Init States
+ ))
+ {
+ };
+#endif
+ typedef msm::back::state_machine<iPod_> iPod;
+
+ void test()
+ {
+ iPod sm;
+ sm.start();
+ // we first press Hold
+ std::cout << "pressing hold" << std::endl;
+ sm.process_event(Hold());
+ // pressing a button is now ignored
+ std::cout << "pressing a button" << std::endl;
+ sm.process_event(SouthPressed());
+ // or even one contained in a submachine
+ sm.process_event(EastPressed());
+ // no more holding
+ std::cout << "no more holding, end interrupt event sent" << std::endl;
+ sm.process_event(NoHold());
+ std::cout << "pressing South button a short time" << std::endl;
+ sm.process_event(SouthPressed());
+ // we suppose a short pressing leading to playing a song
+ sm.process_event(SouthReleased());
+ // we move to the next song
+ std::cout << "we move to the next song" << std::endl;
+ sm.process_event(NextSong());
+ // then back to no song => exit from playing, menu active
+ std::cout << "we press twice the West button (simulated)=> end of playing" << std::endl;
+ sm.process_event(PreviousSong());
+ sm.process_event(PreviousSong());
+ // even in menu mode, pressing play will start playing the first song
+ std::cout << "pressing play/pause" << std::endl;
+ sm.process_event(SouthPressed());
+ sm.process_event(SouthReleased());
+ // of course pausing must be possible
+ std::cout << "pressing play/pause" << std::endl;
+ sm.process_event(SouthPressed());
+ sm.process_event(SouthReleased());
+ std::cout << "pressing play/pause" << std::endl;
+ sm.process_event(SouthPressed());
+ sm.process_event(SouthReleased());
+ // while playing, you can fast forward
+ std::cout << "pressing East button a long time" << std::endl;
+ sm.process_event(EastPressed());
+ // let's suppose the timer just fired
+ sm.process_event(ForwardTimer());
+ sm.process_event(ForwardTimer());
+ // end of fast forwarding
+ std::cout << "releasing East button" << std::endl;
+ sm.process_event(EastReleased());
+ // we now press the middle button to set playing at a given position
+ std::cout << "pressing Middle button, fast forwarding disabled" << std::endl;
+ sm.process_event(MiddleButton());
+ std::cout <<"pressing East button to fast forward" << std::endl;
+ sm.process_event(EastPressed());
+ // we switch off and on
+ std::cout <<"switch off player" << std::endl;
+ sm.process_event(SouthPressed());
+ sm.process_event(OnOffTimer());
+ std::cout <<"switch on player" << std::endl;
+ sm.process_event(SouthPressed());
+ }
+}
+
+int main()
+{
+ test();
+ return 0;
+}
Added: sandbox/msm/libs/msm/doc/BoostCon09/ipod_functors.hpp
==============================================================================
--- (empty file)
+++ sandbox/msm/libs/msm/doc/BoostCon09/ipod_functors.hpp 2009-12-12 19:21:24 EST (Sat, 12 Dec 2009)
@@ -0,0 +1,238 @@
+#ifndef IPOD_FUNCTORS_HPP
+#define IPOD_FUNCTORS_HPP
+#include <boost/msm/front/euml/euml.hpp>
+
+struct NotHolding_Entry : euml_action<NotHolding_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: NotHolding" << std::endl;
+ }
+};
+struct Holding_Entry : euml_action<Holding_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: Holding" << std::endl;
+ }
+};
+struct NotPlaying_Entry : euml_action<NotPlaying_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: NotPlaying" << std::endl;
+ }
+};
+struct NoMenuMode_Entry : euml_action<NoMenuMode_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: NoMenuMode" << std::endl;
+ }
+};
+struct NoOnOffButton_Entry : euml_action<NoOnOffButton_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: NoOnOffButton" << std::endl;
+ }
+};
+struct OffDown_Entry : euml_action<OffDown_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: OffDown" << std::endl;
+ }
+};
+struct PlayerOff_Entry : euml_action<PlayerOff_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: PlayerOff" << std::endl;
+ }
+};
+struct CheckMiddleButton_Entry : euml_action<CheckMiddleButton_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: CheckMiddleButton" << std::endl;
+ }
+};
+struct Playing_Entry : euml_action<Playing_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM& fsm,STATE& )
+ {
+ std::cout << "entering: Playing" << std::endl;
+ std::cout << "playing song:" << fsm.template get_attribute<m_SongIndex>() << std::endl;
+ }
+};
+struct WaitingForNextPrev_Entry : euml_action<WaitingForNextPrev_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: WaitingForNextPrev" << std::endl;
+ }
+};
+struct Paused_Entry : euml_action<Paused_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: Paused" << std::endl;
+ }
+};
+struct WaitingForEnd_Entry : euml_action<WaitingForEnd_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: OffDown" << std::endl;
+ }
+};
+struct NoForward_Entry : euml_action<NoForward_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: NoForward" << std::endl;
+ }
+};
+struct ForwardPressed_Entry : euml_action<ForwardPressed_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: ForwardPressed" << std::endl;
+ }
+};
+struct ForwardPressed_Exit : euml_action<ForwardPressed_Exit>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: ForwardPressed" << std::endl;
+ }
+};
+struct FastForward_Entry : euml_action<FastForward_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: FastForward" << std::endl;
+ }
+};
+struct FastForward_Exit : euml_action<FastForward_Exit>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "leaving: FastForward" << std::endl;
+ }
+};
+struct StdDisplay_Entry : euml_action<StdDisplay_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: StdDisplay" << std::endl;
+ }
+};
+struct SetPosition_Entry : euml_action<SetPosition_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SetPosition" << std::endl;
+ }
+};
+struct SetMark_Entry : euml_action<SetMark_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: SetMark" << std::endl;
+ }
+};
+struct PlayingExit_Entry : euml_action<PlayingExit_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: PlayingExit" << std::endl;
+ }
+};
+struct WaitingForSongChoice_Entry : euml_action<WaitingForSongChoice_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: WaitingForSongChoice" << std::endl;
+ }
+};
+struct StartCurrentSong_Entry : euml_action<StartCurrentSong_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: StartCurrentSong" << std::endl;
+ }
+};
+struct MenuExit_Entry : euml_action<MenuExit_Entry>
+{
+ template <class Event,class FSM,class STATE>
+ void operator()(Event const&,FSM&,STATE& )
+ {
+ std::cout << "entering: MenuExit" << std::endl;
+ }
+};
+struct show_selected_song : euml_action<show_selected_song>
+{
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState& )
+ {
+ std::cout << "selecting song:" << fsm.template get_attribute<m_SongIndex>() << std::endl;
+ }
+};
+struct do_fast_forward : euml_action<do_fast_forward>
+{
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState& )
+ {
+ std::cout << "moving song forward..." << std::endl;
+ }
+};
+struct show_playing_song : euml_action<show_playing_song>
+{
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState& )
+ {
+ std::cout << "playing song:" << fsm.template get_attribute<m_SongIndex>() << std::endl;
+ }
+};
+struct show_player_off : euml_action<show_player_off>
+{
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState& )
+ {
+ std::cout << "turning player off" << std::endl;
+ }
+};
+struct show_player_on : euml_action<show_player_on>
+{
+ template <class FSM,class EVT,class SourceState,class TargetState>
+ void operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState& )
+ {
+ std::cout << "turning player on" << std::endl;
+ }
+};
+#endif
\ No newline at end of file
Added: sandbox/msm/libs/msm/doc/BoostCon09/ipod_menu.gif
==============================================================================
Binary file. No diff available.
Added: sandbox/msm/libs/msm/doc/BoostCon09/ipod_playing.gif
==============================================================================
Binary file. No diff available.
Added: sandbox/msm/libs/msm/doc/BoostCon09/ipod_top.gif
==============================================================================
Binary file. No diff available.
Deleted: sandbox/msm/libs/msm/doc/MsmSession_Handout.pdf
==============================================================================
Binary file. No diff available.