Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r63051 - in branches/release/boost/msm: . back front front/detail front/euml
From: christophe.j.henry_at_[hidden]
Date: 2010-06-17 14:15:22


Author: chenry
Date: 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
New Revision: 63051
URL: http://svn.boost.org/trac/boost/changeset/63051

Log:
added msm
Added:
   branches/release/boost/msm/
      - copied from r62128, /trunk/boost/msm/
   branches/release/boost/msm/back/
      - copied from r62128, /trunk/boost/msm/back/
   branches/release/boost/msm/back/args.hpp
      - copied unchanged from r62128, /trunk/boost/msm/back/args.hpp
   branches/release/boost/msm/back/bind_helpers.hpp
      - copied, changed from r62128, /trunk/boost/msm/back/bind_helpers.hpp
   branches/release/boost/msm/back/common_types.hpp
      - copied unchanged from r62128, /trunk/boost/msm/back/common_types.hpp
   branches/release/boost/msm/back/copy_policies.hpp
      - copied, changed from r62128, /trunk/boost/msm/back/copy_policies.hpp
   branches/release/boost/msm/back/default_compile_policy.hpp
      - copied, changed from r62128, /trunk/boost/msm/back/default_compile_policy.hpp
   branches/release/boost/msm/back/dispatch_table.hpp
      - copied, changed from r62128, /trunk/boost/msm/back/dispatch_table.hpp
   branches/release/boost/msm/back/favor_compile_time.hpp
      - copied, changed from r62128, /trunk/boost/msm/back/favor_compile_time.hpp
   branches/release/boost/msm/back/history_policies.hpp
      - copied, changed from r62128, /trunk/boost/msm/back/history_policies.hpp
   branches/release/boost/msm/back/metafunctions.hpp
      - copied, changed from r62128, /trunk/boost/msm/back/metafunctions.hpp
   branches/release/boost/msm/back/state_machine.hpp
      - copied, changed from r62128, /trunk/boost/msm/back/state_machine.hpp
   branches/release/boost/msm/back/tools.hpp
      - copied unchanged from r62128, /trunk/boost/msm/back/tools.hpp
   branches/release/boost/msm/common.hpp
      - copied unchanged from r62128, /trunk/boost/msm/common.hpp
   branches/release/boost/msm/front/
      - copied from r62128, /trunk/boost/msm/front/
   branches/release/boost/msm/front/common_states.hpp
      - copied unchanged from r62128, /trunk/boost/msm/front/common_states.hpp
   branches/release/boost/msm/front/completion_event.hpp
      - copied unchanged from r62128, /trunk/boost/msm/front/completion_event.hpp
   branches/release/boost/msm/front/detail/
      - copied from r62128, /trunk/boost/msm/front/detail/
   branches/release/boost/msm/front/detail/common_states.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/detail/common_states.hpp
   branches/release/boost/msm/front/detail/row2_helper.hpp
      - copied unchanged from r62128, /trunk/boost/msm/front/detail/row2_helper.hpp
   branches/release/boost/msm/front/euml/
      - copied from r62128, /trunk/boost/msm/front/euml/
   branches/release/boost/msm/front/euml/algorithm.hpp
      - copied unchanged from r62128, /trunk/boost/msm/front/euml/algorithm.hpp
   branches/release/boost/msm/front/euml/common.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/common.hpp
   branches/release/boost/msm/front/euml/container.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/container.hpp
   branches/release/boost/msm/front/euml/euml.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/euml.hpp
   branches/release/boost/msm/front/euml/euml_typeof.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/euml_typeof.hpp
   branches/release/boost/msm/front/euml/guard_grammar.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/guard_grammar.hpp
   branches/release/boost/msm/front/euml/iteration.hpp
      - copied unchanged from r62128, /trunk/boost/msm/front/euml/iteration.hpp
   branches/release/boost/msm/front/euml/operator.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/operator.hpp
   branches/release/boost/msm/front/euml/querying.hpp
      - copied unchanged from r62128, /trunk/boost/msm/front/euml/querying.hpp
   branches/release/boost/msm/front/euml/state_grammar.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/state_grammar.hpp
   branches/release/boost/msm/front/euml/stl.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/stl.hpp
   branches/release/boost/msm/front/euml/stt_grammar.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/stt_grammar.hpp
   branches/release/boost/msm/front/euml/transformation.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/euml/transformation.hpp
   branches/release/boost/msm/front/functor_row.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/functor_row.hpp
   branches/release/boost/msm/front/internal_row.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/internal_row.hpp
   branches/release/boost/msm/front/row2.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/row2.hpp
   branches/release/boost/msm/front/state_machine_def.hpp
      - copied, changed from r62128, /trunk/boost/msm/front/state_machine_def.hpp
   branches/release/boost/msm/front/states.hpp
      - copied unchanged from r62128, /trunk/boost/msm/front/states.hpp
   branches/release/boost/msm/row_tags.hpp
      - copied unchanged from r62128, /trunk/boost/msm/row_tags.hpp
Text files modified:
   branches/release/boost/msm/back/bind_helpers.hpp | 24
   branches/release/boost/msm/back/copy_policies.hpp | 2
   branches/release/boost/msm/back/default_compile_policy.hpp | 2
   branches/release/boost/msm/back/dispatch_table.hpp | 34
   branches/release/boost/msm/back/favor_compile_time.hpp | 232 ++--
   branches/release/boost/msm/back/history_policies.hpp | 36
   branches/release/boost/msm/back/metafunctions.hpp | 188 ++--
   branches/release/boost/msm/back/state_machine.hpp | 210 ++--
   branches/release/boost/msm/front/detail/common_states.hpp | 14
   branches/release/boost/msm/front/euml/common.hpp | 356 ++++----
   branches/release/boost/msm/front/euml/container.hpp | 944 +++++++++++-----------
   branches/release/boost/msm/front/euml/euml.hpp | 2
   branches/release/boost/msm/front/euml/euml_typeof.hpp | 2
   branches/release/boost/msm/front/euml/guard_grammar.hpp | 124 +-
   branches/release/boost/msm/front/euml/operator.hpp | 1672 ++++++++++++++++++++--------------------
   branches/release/boost/msm/front/euml/state_grammar.hpp | 428 +++++-----
   branches/release/boost/msm/front/euml/stl.hpp | 2
   branches/release/boost/msm/front/euml/stt_grammar.hpp | 8
   branches/release/boost/msm/front/euml/transformation.hpp | 132 +-
   branches/release/boost/msm/front/functor_row.hpp | 8
   branches/release/boost/msm/front/internal_row.hpp | 50
   branches/release/boost/msm/front/row2.hpp | 148 +-
   branches/release/boost/msm/front/state_machine_def.hpp | 192 ++--
   23 files changed, 2413 insertions(+), 2397 deletions(-)

Copied: branches/release/boost/msm/back/bind_helpers.hpp (from r62128, /trunk/boost/msm/back/bind_helpers.hpp)
==============================================================================
--- /trunk/boost/msm/back/bind_helpers.hpp (original)
+++ branches/release/boost/msm/back/bind_helpers.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -18,22 +18,24 @@
     // helper to replace std::plus as the lack of implicit conversion makes it not usable in one of our bind
     template<class _Ty,class _Tz>
     struct plus2
- : public std::binary_function<_Ty, _Tz, _Ty>
- { // functor for operator+
- _Ty operator()( _Ty _Left, _Tz _Right) const
- { // apply operator+ to operands
- return (_Left + _Right);
- }
+ : public std::binary_function<_Ty, _Tz, _Ty>
+ {
+ // functor for operator+
+ _Ty operator()( _Ty _Left, _Tz _Right) const
+ {
+ // apply operator+ to operands
+ return (_Left + _Right);
+ }
     };
     // helper to dereference a pointer to a function pointer
     template <class T>
     struct deref
     {
- typedef T& result_type;
- T& operator()(T* f) const
- {
- return *f;
- }
+ typedef T& result_type;
+ T& operator()(T* f) const
+ {
+ return *f;
+ }
     };
 } } }//boost::msm::back
 #endif //BOOST_MSM_BACK_BIND_HELPERS_H

Copied: branches/release/boost/msm/back/copy_policies.hpp (from r62128, /trunk/boost/msm/back/copy_policies.hpp)
==============================================================================
--- /trunk/boost/msm/back/copy_policies.hpp (original)
+++ branches/release/boost/msm/back/copy_policies.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -19,7 +19,7 @@
     struct NoCopy : ::boost::noncopyable
     {
     };
-
+
     // allows deep copy
     struct DeepCopy
     {

Copied: branches/release/boost/msm/back/default_compile_policy.hpp (from r62128, /trunk/boost/msm/back/default_compile_policy.hpp)
==============================================================================
--- /trunk/boost/msm/back/default_compile_policy.hpp (original)
+++ branches/release/boost/msm/back/default_compile_policy.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -17,7 +17,7 @@
 {
 struct favor_runtime_speed
 {
- typedef ::boost::mpl::true_ add_forwarding_rows;
+ typedef ::boost::mpl::true_ add_forwarding_rows;
 };
 
 }}}// boost::msm::back

Copied: branches/release/boost/msm/back/dispatch_table.hpp (from r62128, /trunk/boost/msm/back/dispatch_table.hpp)
==============================================================================
--- /trunk/boost/msm/back/dispatch_table.hpp (original)
+++ branches/release/boost/msm/back/dispatch_table.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -42,7 +42,7 @@
     template< typename Seq,typename AnEvent,typename State >
     struct chain_row
     {
- typedef State current_state_type;
+ typedef State current_state_type;
         typedef AnEvent transition_event;
 
         // helper for building a disable/enable_if-controlled execute function
@@ -153,18 +153,18 @@
     template <class EventType,class Enable=void>
     struct default_init_cell
     {
- default_init_cell(dispatch_table* self_,cell* tofill_entries_)
- : self(self_),tofill_entries(tofill_entries_)
- {}
+ default_init_cell(dispatch_table* self_,cell* tofill_entries_)
+ : self(self_),tofill_entries(tofill_entries_)
+ {}
         template <class State>
         typename ::boost::enable_if<typename has_state_delayed_event<State,Event>::type,void>::type
         operator()(boost::msm::wrap<State> const&,boost::msm::back::dummy<0> = 0)
- {
+ {
             typedef typename create_stt<Fsm>::type stt;
             BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
             cell call_no_transition = &Fsm::defer_transition;
             tofill_entries[state_id] = call_no_transition;
- }
+ }
         template <class State>
         typename ::boost::disable_if<typename has_state_delayed_event<State,Event>::type,void >::type
         operator()(boost::msm::wrap<State> const&,boost::msm::back::dummy<1> = 0)
@@ -175,8 +175,8 @@
             tofill_entries[state_id] = call_no_transition;
         }
 
- dispatch_table* self;
- cell* tofill_entries;
+ dispatch_table* self;
+ cell* tofill_entries;
     };
 
     // variant for anonymous transitions
@@ -185,23 +185,23 @@
                              typename ::boost::enable_if<
                                 typename is_completion_event<EventType>::type>::type>
     {
- default_init_cell(dispatch_table* self_,cell* tofill_entries_)
- : self(self_),tofill_entries(tofill_entries_)
- {}
+ default_init_cell(dispatch_table* self_,cell* tofill_entries_)
+ : self(self_),tofill_entries(tofill_entries_)
+ {}
 
         // this event is a compound one (not a real one, just one for use in event-less transitions)
         // Note this event cannot be used as deferred!
- template <class State>
+ template <class State>
         void operator()(boost::msm::wrap<State> const&)
- {
+ {
             typedef typename create_stt<Fsm>::type stt;
             BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
             cell call_no_transition = &Fsm::default_eventless_transition;
             tofill_entries[state_id] = call_no_transition;
- }
+ }
 
- dispatch_table* self;
- cell* tofill_entries;
+ dispatch_table* self;
+ cell* tofill_entries;
     };
 
  public:
@@ -209,7 +209,7 @@
     dispatch_table()
     {
         // Initialize cells for no transition
- ::boost::mpl::for_each<typename generate_state_set<Stt>::type,
+ ::boost::mpl::for_each<typename generate_state_set<Stt>::type,
                                boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                         (default_init_cell<Event>(this,entries));
 

Copied: branches/release/boost/msm/back/favor_compile_time.hpp (from r62128, /trunk/boost/msm/back/favor_compile_time.hpp)
==============================================================================
--- /trunk/boost/msm/back/favor_compile_time.hpp (original)
+++ branches/release/boost/msm/back/favor_compile_time.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -29,41 +29,41 @@
 template <class Fsm>
 struct process_any_event_helper
 {
- process_any_event_helper(msm::back::HandledEnum& res_,Fsm* self_,::boost::any any_event_):
- res(res_),self(self_),any_event(any_event_),finished(false){}
- template <class Event>
- void operator()(boost::msm::wrap<Event> const&)
- {
- if ( ! finished && ::boost::any_cast<Event>(&any_event)!=0)
- {
- finished = true;
- res = self->process_event(::boost::any_cast<Event>(any_event));
- }
- }
+ process_any_event_helper(msm::back::HandledEnum& res_,Fsm* self_,::boost::any any_event_):
+ res(res_),self(self_),any_event(any_event_),finished(false){}
+ template <class Event>
+ void operator()(boost::msm::wrap<Event> const&)
+ {
+ if ( ! finished && ::boost::any_cast<Event>(&any_event)!=0)
+ {
+ finished = true;
+ res = self->process_event(::boost::any_cast<Event>(any_event));
+ }
+ }
 private:
- msm::back::HandledEnum& res;
- Fsm* self;
- ::boost::any any_event;
- bool finished;
+ msm::back::HandledEnum& res;
+ Fsm* self;
+ ::boost::any any_event;
+ bool finished;
 };
 
-#define BOOST_MSM_BACK_GENERATE_PROCESS_EVENT(fsmname) \
+#define BOOST_MSM_BACK_GENERATE_PROCESS_EVENT(fsmname) \
     namespace boost { namespace msm { namespace back{ \
     template<> \
- ::boost::msm::back::HandledEnum fsmname::process_any_event( ::boost::any const& any_event) \
- { \
- typedef ::boost::msm::back::recursive_get_transition_table<fsmname>::type stt; \
- typedef ::boost::msm::back::generate_event_set<stt>::type all_events; \
- ::boost::msm::back::HandledEnum res= ::boost::msm::back::HANDLED_FALSE; \
- ::boost::mpl::for_each<all_events, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > \
- (::boost::msm::back::process_any_event_helper<fsmname>(res,this,any_event)); \
- return res; \
- } \
+ ::boost::msm::back::HandledEnum fsmname::process_any_event( ::boost::any const& any_event) \
+ { \
+ typedef ::boost::msm::back::recursive_get_transition_table<fsmname>::type stt; \
+ typedef ::boost::msm::back::generate_event_set<stt>::type all_events; \
+ ::boost::msm::back::HandledEnum res= ::boost::msm::back::HANDLED_FALSE; \
+ ::boost::mpl::for_each<all_events, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > \
+ (::boost::msm::back::process_any_event_helper<fsmname>(res,this,any_event)); \
+ return res; \
+ } \
     }}}
 
 struct favor_compile_time
 {
- typedef ::boost::mpl::false_ add_forwarding_rows;
+ typedef ::boost::mpl::false_ add_forwarding_rows;
 };
 
 // Generates a singleton runtime lookup table that maps current state
@@ -82,23 +82,23 @@
     typedef typename generate_state_set<Stt>::type state_list;
     BOOST_STATIC_CONSTANT(int, max_state = ( ::boost::mpl::size<state_list>::value));
 
- struct chain_row
- {
- HandledEnum operator()(Fsm& fsm, int region,int state,Event const& evt) const
- {
- HandledEnum res = HANDLED_FALSE;
- typename std::deque<cell>::const_iterator it = one_state.begin();
- while (it != one_state.end() && res != HANDLED_TRUE)
- {
- HandledEnum handled = (*it)(fsm,region,state,evt);
- res = ((HANDLED_GUARD_REJECT==handled) || (HANDLED_GUARD_REJECT==res))?
- HANDLED_GUARD_REJECT:handled;
- ++it;
- }
- return res;
- }
- std::deque<cell> one_state;
- };
+ struct chain_row
+ {
+ HandledEnum operator()(Fsm& fsm, int region,int state,Event const& evt) const
+ {
+ HandledEnum res = HANDLED_FALSE;
+ typename std::deque<cell>::const_iterator it = one_state.begin();
+ while (it != one_state.end() && res != HANDLED_TRUE)
+ {
+ HandledEnum handled = (*it)(fsm,region,state,evt);
+ res = ((HANDLED_GUARD_REJECT==handled) || (HANDLED_GUARD_REJECT==res))?
+ HANDLED_GUARD_REJECT:handled;
+ ++it;
+ }
+ return res;
+ }
+ std::deque<cell> one_state;
+ };
     template <class TransitionState>
     static HandledEnum call_submachine(Fsm& fsm, int region, int state, Event const& evt)
     {
@@ -155,64 +155,64 @@
     template <class EventType,class Enable=void>
     struct default_init_cell
     {
- default_init_cell(dispatch_table* self_,chain_row* tofill_entries_)
- : self(self_),tofill_entries(tofill_entries_)
- {}
- template <bool deferred,bool composite, int some_dummy=0>
- struct helper
- {};
- template <int some_dummy> struct helper<true,false,some_dummy>
- {
- template <class State>
- static void execute(boost::msm::wrap<State> const&,chain_row* tofill)
- {
- typedef typename create_stt<Fsm>::type stt;
- BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
- cell call_no_transition = &Fsm::defer_transition;
- tofill[state_id].one_state.push_back(call_no_transition);
- }
- };
- template <int some_dummy> struct helper<true,true,some_dummy>
- {
- template <class State>
- static void execute(boost::msm::wrap<State> const&,chain_row* tofill)
- {
- typedef typename create_stt<Fsm>::type stt;
- BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
- cell call_no_transition = &Fsm::defer_transition;
- tofill[state_id].one_state.push_back(call_no_transition);
- }
- };
- template <int some_dummy> struct helper<false,true,some_dummy>
- {
- template <class State>
- static void execute(boost::msm::wrap<State> const&,chain_row* tofill)
- {
- typedef typename create_stt<Fsm>::type stt;
- BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
- cell call_no_transition = &call_submachine< State >;
- tofill[state_id].one_state.push_front(call_no_transition);
- }
- };
- template <int some_dummy> struct helper<false,false,some_dummy>
- {
- template <class State>
- static void execute(boost::msm::wrap<State> const&,chain_row* tofill)
- {
- typedef typename create_stt<Fsm>::type stt;
- BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
- cell call_no_transition = &Fsm::call_no_transition;
- tofill[state_id].one_state.push_back(call_no_transition);
- }
- };
- template <class State>
- void operator()(boost::msm::wrap<State> const& s)
- {
- helper<has_state_delayed_event<State,Event>::type::value,
- is_composite_state<State>::type::value>::execute(s,tofill_entries);
- }
- dispatch_table* self;
- chain_row* tofill_entries;
+ default_init_cell(dispatch_table* self_,chain_row* tofill_entries_)
+ : self(self_),tofill_entries(tofill_entries_)
+ {}
+ template <bool deferred,bool composite, int some_dummy=0>
+ struct helper
+ {};
+ template <int some_dummy> struct helper<true,false,some_dummy>
+ {
+ template <class State>
+ static void execute(boost::msm::wrap<State> const&,chain_row* tofill)
+ {
+ typedef typename create_stt<Fsm>::type stt;
+ BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
+ cell call_no_transition = &Fsm::defer_transition;
+ tofill[state_id].one_state.push_back(call_no_transition);
+ }
+ };
+ template <int some_dummy> struct helper<true,true,some_dummy>
+ {
+ template <class State>
+ static void execute(boost::msm::wrap<State> const&,chain_row* tofill)
+ {
+ typedef typename create_stt<Fsm>::type stt;
+ BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
+ cell call_no_transition = &Fsm::defer_transition;
+ tofill[state_id].one_state.push_back(call_no_transition);
+ }
+ };
+ template <int some_dummy> struct helper<false,true,some_dummy>
+ {
+ template <class State>
+ static void execute(boost::msm::wrap<State> const&,chain_row* tofill)
+ {
+ typedef typename create_stt<Fsm>::type stt;
+ BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
+ cell call_no_transition = &call_submachine< State >;
+ tofill[state_id].one_state.push_front(call_no_transition);
+ }
+ };
+ template <int some_dummy> struct helper<false,false,some_dummy>
+ {
+ template <class State>
+ static void execute(boost::msm::wrap<State> const&,chain_row* tofill)
+ {
+ typedef typename create_stt<Fsm>::type stt;
+ BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
+ cell call_no_transition = &Fsm::call_no_transition;
+ tofill[state_id].one_state.push_back(call_no_transition);
+ }
+ };
+ template <class State>
+ void operator()(boost::msm::wrap<State> const& s)
+ {
+ helper<has_state_delayed_event<State,Event>::type::value,
+ is_composite_state<State>::type::value>::execute(s,tofill_entries);
+ }
+ dispatch_table* self;
+ chain_row* tofill_entries;
     };
 
     // variant for anonymous transitions
@@ -221,23 +221,23 @@
                              typename ::boost::enable_if<
                                 typename is_completion_event<EventType>::type>::type>
     {
- default_init_cell(dispatch_table* self_,chain_row* tofill_entries_)
- : self(self_),tofill_entries(tofill_entries_)
- {}
+ default_init_cell(dispatch_table* self_,chain_row* tofill_entries_)
+ : self(self_),tofill_entries(tofill_entries_)
+ {}
 
         // this event is a compound one (not a real one, just one for use in event-less transitions)
         // Note this event cannot be used as deferred!
- template <class State>
+ template <class State>
         void operator()(boost::msm::wrap<State> const&)
- {
+ {
             typedef typename create_stt<Fsm>::type stt;
             BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value));
             cell call_no_transition = &Fsm::default_eventless_transition;
             tofill_entries[state_id].one_state.push_back(call_no_transition);
- }
+ }
 
- dispatch_table* self;
- chain_row* tofill_entries;
+ dispatch_table* self;
+ chain_row* tofill_entries;
     };
 
  public:
@@ -245,13 +245,13 @@
     dispatch_table()
     {
         // Initialize cells for no transition
- ::boost::mpl::for_each<
- ::boost::mpl::filter_view<
- Stt, ::boost::is_base_of<transition_event< ::boost::mpl::placeholders::_>, Event> > >
- (init_cell(this));
+ ::boost::mpl::for_each<
+ ::boost::mpl::filter_view<
+ Stt, ::boost::is_base_of<transition_event< ::boost::mpl::placeholders::_>, Event> > >
+ (init_cell(this));
 
- ::boost::mpl::for_each<
- typename generate_state_set<Stt>::type,
+ ::boost::mpl::for_each<
+ typename generate_state_set<Stt>::type,
             boost::msm::wrap< ::boost::mpl::placeholders::_1> >
          (default_init_cell<Event>(this,entries));
 
@@ -261,7 +261,7 @@
     static const dispatch_table instance;
 
  public: // data members
- chain_row entries[max_state];
+ chain_row entries[max_state];
 };
 
 template <class Fsm,class Stt, class Event>

Copied: branches/release/boost/msm/back/history_policies.hpp (from r62128, /trunk/boost/msm/back/history_policies.hpp)
==============================================================================
--- /trunk/boost/msm/back/history_policies.hpp (original)
+++ branches/release/boost/msm/back/history_policies.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -28,18 +28,18 @@
     void set_initial_states(int* const initial_states)
     {
         for (int i=0;i<NumberOfRegions;++i)
- m_initialStates[i] = initial_states[i];
+ m_initialStates[i] = initial_states[i];
     }
     void history_exit(int* const )
     {
- // ignore
+ // ignore
     }
     // returns the state where the state machine should be at start
- template <class Event>
+ template <class Event>
     int* const history_entry(Event const& )
     {
- // always come back to the original state
- return m_initialStates;
+ // always come back to the original state
+ return m_initialStates;
     }
     NoHistoryImpl<NumberOfRegions>& operator=(NoHistoryImpl<NumberOfRegions> const& rhs)
     {
@@ -63,19 +63,19 @@
     void set_initial_states(int* const initial_states)
     {
         for (int i=0;i<NumberOfRegions;++i)
- m_initialStates[i] = initial_states[i];
+ m_initialStates[i] = initial_states[i];
     }
     void history_exit(int* const current_states)
     {
         for (int i=0;i<NumberOfRegions;++i)
- m_initialStates[i] = current_states[i];
+ m_initialStates[i] = current_states[i];
     }
     // returns the state where the state machine should be at start
- template <class Event>
+ template <class Event>
     int* const history_entry(Event const& )
     {
- // always load back the last active state
- return m_initialStates;
+ // always load back the last active state
+ return m_initialStates;
     }
     AlwaysHistoryImpl<NumberOfRegions>& operator=(AlwaysHistoryImpl<NumberOfRegions> const& rhs)
     {
@@ -100,25 +100,25 @@
     {
         for (int i=0;i<NumberOfRegions;++i)
         {
- m_currentStates[i] = initial_states[i];
+ m_currentStates[i] = initial_states[i];
             m_initialStates[i] = initial_states[i];
         }
     }
     void history_exit(int* const current_states)
     {
         for (int i=0;i<NumberOfRegions;++i)
- m_currentStates[i] = current_states[i];
+ m_currentStates[i] = current_states[i];
     }
     // returns the state where the state machine should be at start
     template <class Event>
- int* const history_entry(Event const&)
+ int* const history_entry(Event const&)
     {
         if ( ::boost::mpl::contains<Events,Event>::value)
- {
- return m_currentStates;
- }
- // not one of our events, no history
- return m_initialStates;
+ {
+ return m_currentStates;
+ }
+ // not one of our events, no history
+ return m_initialStates;
     }
     ShallowHistoryImpl<Events,NumberOfRegions>& operator=(ShallowHistoryImpl<Events,NumberOfRegions> const& rhs)
     {

Copied: branches/release/boost/msm/back/metafunctions.hpp (from r62128, /trunk/boost/msm/back/metafunctions.hpp)
==============================================================================
--- /trunk/boost/msm/back/metafunctions.hpp (original)
+++ branches/release/boost/msm/back/metafunctions.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -92,49 +92,49 @@
 struct generate_state_ids
 {
     typedef typename
- ::boost::mpl::fold<
- stt,::boost::mpl::pair< ::boost::mpl::map< >, ::boost::mpl::int_<0> >,
- ::boost::mpl::pair<
- ::boost::mpl::if_<
- ::boost::mpl::has_key< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
+ ::boost::mpl::fold<
+ stt,::boost::mpl::pair< ::boost::mpl::map< >, ::boost::mpl::int_<0> >,
+ ::boost::mpl::pair<
+ ::boost::mpl::if_<
+ ::boost::mpl::has_key< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
                                             transition_source_type< ::boost::mpl::placeholders::_2> >,
- ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
- ::boost::mpl::insert< ::boost::mpl::first<mpl::placeholders::_1>,
- make_pair_source_state_id< ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
- ::boost::mpl::placeholders::_2> >
- >,
- ::boost::mpl::if_<
- ::boost::mpl::has_key< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
+ ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
+ ::boost::mpl::insert< ::boost::mpl::first<mpl::placeholders::_1>,
+ make_pair_source_state_id< ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
+ ::boost::mpl::placeholders::_2> >
+ >,
+ ::boost::mpl::if_<
+ ::boost::mpl::has_key< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
                                            transition_source_type< ::boost::mpl::placeholders::_2> >,
- ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
- ::boost::mpl::next< ::boost::mpl::second<mpl::placeholders::_1 > >
- >
- > //pair
- >::type source_state_ids;
+ ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
+ ::boost::mpl::next< ::boost::mpl::second<mpl::placeholders::_1 > >
+ >
+ > //pair
+ >::type source_state_ids;
     typedef typename ::boost::mpl::first<source_state_ids>::type source_state_map;
     typedef typename ::boost::mpl::second<source_state_ids>::type highest_state_id;
 
 
     typedef typename
- ::boost::mpl::fold<
- stt,::boost::mpl::pair<source_state_map,highest_state_id >,
- ::boost::mpl::pair<
- ::boost::mpl::if_<
- ::boost::mpl::has_key< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
+ ::boost::mpl::fold<
+ stt,::boost::mpl::pair<source_state_map,highest_state_id >,
+ ::boost::mpl::pair<
+ ::boost::mpl::if_<
+ ::boost::mpl::has_key< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
                                             transition_target_type< ::boost::mpl::placeholders::_2> >,
- ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
- ::boost::mpl::insert< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
- make_pair_target_state_id< ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
- ::boost::mpl::placeholders::_2> >
- >,
- ::boost::mpl::if_<
- ::boost::mpl::has_key< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
+ ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
+ ::boost::mpl::insert< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
+ make_pair_target_state_id< ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
+ ::boost::mpl::placeholders::_2> >
+ >,
+ ::boost::mpl::if_<
+ ::boost::mpl::has_key< ::boost::mpl::first< ::boost::mpl::placeholders::_1>,
                                            transition_target_type< ::boost::mpl::placeholders::_2> >,
- ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
- ::boost::mpl::next< ::boost::mpl::second< ::boost::mpl::placeholders::_1 > >
- >
- > //pair
- >::type all_state_ids;
+ ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
+ ::boost::mpl::next< ::boost::mpl::second< ::boost::mpl::placeholders::_1 > >
+ >
+ > //pair
+ >::type all_state_ids;
     typedef typename ::boost::mpl::first<all_state_ids>::type type;
 };
 
@@ -151,9 +151,9 @@
 struct get_initial_states
 {
     typedef typename ::boost::mpl::if_<
- ::boost::mpl::is_sequence<States>,
- States,
- typename ::boost::mpl::push_back< ::boost::mpl::vector0<>,States>::type >::type type;
+ ::boost::mpl::is_sequence<States>,
+ States,
+ typename ::boost::mpl::push_back< ::boost::mpl::vector0<>,States>::type >::type type;
 };
 
 // returns a mpl::int_ containing the size of a region. If the argument is not a sequence, returns 1
@@ -161,9 +161,9 @@
 struct get_number_of_regions
 {
     typedef typename mpl::if_<
- ::boost::mpl::is_sequence<region>,
- ::boost::mpl::size<region>,
- ::boost::mpl::int_<1> >::type type;
+ ::boost::mpl::is_sequence<region>,
+ ::boost::mpl::size<region>,
+ ::boost::mpl::int_<1> >::type type;
 };
 
 // builds a mpl::vector of initial states
@@ -171,9 +171,9 @@
 struct get_regions_as_sequence
 {
     typedef typename ::boost::mpl::if_<
- ::boost::mpl::is_sequence<region>,
- region,
- typename ::boost::mpl::push_back< ::boost::mpl::vector0<>,region>::type >::type type;
+ ::boost::mpl::is_sequence<region>,
+ region,
+ typename ::boost::mpl::push_back< ::boost::mpl::vector0<>,region>::type >::type type;
 };
 
 template <class ToCreateSeq>
@@ -216,8 +216,8 @@
 {
     // instead of the rows we want only the names of the states (from source)
     typedef typename
- ::boost::mpl::transform<
- stt,transition_source_type< ::boost::mpl::placeholders::_1> >::type type;
+ ::boost::mpl::transform<
+ stt,transition_source_type< ::boost::mpl::placeholders::_1> >::type type;
 };
 
 // transform a transition table in a container of target states
@@ -226,8 +226,8 @@
 {
     // instead of the rows we want only the names of the states (from source)
     typedef typename
- ::boost::mpl::transform<
- stt,transition_target_type< ::boost::mpl::placeholders::_1> >::type type;
+ ::boost::mpl::transform<
+ stt,transition_target_type< ::boost::mpl::placeholders::_1> >::type type;
 };
 
 template <class stt>
@@ -237,15 +237,15 @@
     typedef typename keep_source_names<stt>::type sources;
     typedef typename keep_target_names<stt>::type targets;
     typedef typename
- ::boost::mpl::fold<
- sources, ::boost::mpl::set<>,
- ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2>
- >::type source_set;
+ ::boost::mpl::fold<
+ sources, ::boost::mpl::set<>,
+ ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2>
+ >::type source_set;
     typedef typename
- ::boost::mpl::fold<
- targets,source_set,
- ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2>
- >::type type;
+ ::boost::mpl::fold<
+ targets,source_set,
+ ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2>
+ >::type type;
 };
 
 // iterates through the transition table and generate a mpl::set<> containing all the events
@@ -271,8 +271,8 @@
     typedef typename ::boost::mpl::find<typename State::deferred_events,Event>::type found;
     typedef typename ::boost::mpl::if_<
         ::boost::is_same<found,typename ::boost::mpl::end<typename State::deferred_events>::type >,
- ::boost::mpl::bool_<false>,
- ::boost::mpl::bool_<true> >::type type;
+ ::boost::mpl::bool_<false>,
+ ::boost::mpl::bool_<true> >::type type;
 };
 // returns a mpl::bool_<true> if State has any deferred event
 template <class State>
@@ -351,15 +351,15 @@
     typedef typename get_regions_as_sequence<typename Derived::initial_state>::type init_states;
     // iterate through the initial states and add them in the stt if not already there
     typedef typename
- ::boost::mpl::fold<
- init_states,Stt,
- ::boost::mpl::if_<
- ::boost::mpl::has_key<states, ::boost::mpl::placeholders::_2>,
- ::boost::mpl::placeholders::_1,
- ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::end<mpl::placeholders::_1>,
- not_a_row< ::boost::mpl::placeholders::_2 > >
- >
- >::type with_init;
+ ::boost::mpl::fold<
+ init_states,Stt,
+ ::boost::mpl::if_<
+ ::boost::mpl::has_key<states, ::boost::mpl::placeholders::_2>,
+ ::boost::mpl::placeholders::_1,
+ ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::end<mpl::placeholders::_1>,
+ not_a_row< ::boost::mpl::placeholders::_2 > >
+ >
+ >::type with_init;
     // do the same for states marked as explicitly created
     typedef typename get_explicit_creation_as_sequence<
        typename ::boost::mpl::eval_if<
@@ -369,19 +369,19 @@
>::type fake_explicit_created;
 
     typedef typename
- ::boost::mpl::transform<
- fake_explicit_created,convert_fake_state< ::boost::mpl::placeholders::_1,Derived> >::type explicit_created;
+ ::boost::mpl::transform<
+ fake_explicit_created,convert_fake_state< ::boost::mpl::placeholders::_1,Derived> >::type explicit_created;
 
     typedef typename
- ::boost::mpl::fold<
- explicit_created,with_init,
- ::boost::mpl::if_<
- ::boost::mpl::has_key<states, ::boost::mpl::placeholders::_2>,
- ::boost::mpl::placeholders::_1,
- ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::end<mpl::placeholders::_1>,
- not_a_row< ::boost::mpl::placeholders::_2 > >
- >
- >::type type;
+ ::boost::mpl::fold<
+ explicit_created,with_init,
+ ::boost::mpl::if_<
+ ::boost::mpl::has_key<states, ::boost::mpl::placeholders::_2>,
+ ::boost::mpl::placeholders::_1,
+ ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::end<mpl::placeholders::_1>,
+ not_a_row< ::boost::mpl::placeholders::_2 > >
+ >
+ >::type type;
 };
 
 // returns the transition table of a Composite state
@@ -397,16 +397,16 @@
 {
     // get the transition table of the state if it's a state machine
     typedef typename ::boost::mpl::eval_if<typename is_composite_state<Composite>::type,
- get_transition_table<Composite>,
- ::boost::mpl::vector0<> >::type org_table;
+ get_transition_table<Composite>,
+ ::boost::mpl::vector0<> >::type org_table;
 
     typedef typename generate_state_set<org_table>::type states;
 
     // and for every substate, recursively get the transition table if it's a state machine
     typedef typename ::boost::mpl::fold<
- states,org_table,
- ::boost::mpl::insert_range< ::boost::mpl::placeholders::_1, ::boost::mpl::end<mpl::placeholders::_1>,
- recursive_get_transition_table< ::boost::mpl::placeholders::_2 > >
+ states,org_table,
+ ::boost::mpl::insert_range< ::boost::mpl::placeholders::_1, ::boost::mpl::end<mpl::placeholders::_1>,
+ recursive_get_transition_table< ::boost::mpl::placeholders::_2 > >
>::type type;
 
 };
@@ -460,10 +460,10 @@
 
     typedef typename ::boost::mpl::fold<
         event_list, ::boost::mpl::set<>,
- ::boost::mpl::if_<
- is_completion_event< ::boost::mpl::placeholders::_2>,
- ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2 >,
- ::boost::mpl::placeholders::_1 >
+ ::boost::mpl::if_<
+ is_completion_event< ::boost::mpl::placeholders::_2>,
+ ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2 >,
+ ::boost::mpl::placeholders::_1 >
>::type type;
 };
 
@@ -548,10 +548,10 @@
 {
     typedef typename ::boost::mpl::fold<
         typename StateType::flag_list, ::boost::mpl::set<>,
- ::boost::mpl::if_<
- has_event_blocking_flag< ::boost::mpl::placeholders::_2>,
- ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2 >,
- ::boost::mpl::placeholders::_1 >
+ ::boost::mpl::if_<
+ has_event_blocking_flag< ::boost::mpl::placeholders::_2>,
+ ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2 >,
+ ::boost::mpl::placeholders::_1 >
>::type blocking_flags;
 
     typedef typename ::boost::mpl::if_<
@@ -568,10 +568,10 @@
 
     typedef typename ::boost::mpl::fold<
         state_list, ::boost::mpl::set<>,
- ::boost::mpl::if_<
- is_state_blocking< ::boost::mpl::placeholders::_2>,
- ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2 >,
- ::boost::mpl::placeholders::_1 >
+ ::boost::mpl::if_<
+ is_state_blocking< ::boost::mpl::placeholders::_2>,
+ ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2 >,
+ ::boost::mpl::placeholders::_1 >
>::type blocking_states;
 
     typedef typename ::boost::mpl::if_<

Copied: branches/release/boost/msm/back/state_machine.hpp (from r62128, /trunk/boost/msm/back/state_machine.hpp)
==============================================================================
--- /trunk/boost/msm/back/state_machine.hpp (original)
+++ branches/release/boost/msm/back/state_machine.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -42,8 +42,9 @@
 #include <boost/bind.hpp>
 #include <boost/bind/apply.hpp>
 #include <boost/function.hpp>
+#ifndef BOOST_NO_RTTI
 #include <boost/any.hpp>
-
+#endif
 #include <boost/msm/row_tags.hpp>
 #include <boost/msm/back/metafunctions.hpp>
 #include <boost/msm/back/history_policies.hpp>
@@ -95,7 +96,7 @@
     typedef ::boost::function<
         execute_return () > deferred_fct;
     typedef std::deque<deferred_fct > deferred_events_queue_t;
- typedef std::queue<transition_fct > events_queue_t;
+ typedef std::queue<transition_fct > events_queue_t;
     typedef bool (*flag_handler)(library_sm&);
 
     // all state machines are friend with each other to allow embedding any of them in another fsm
@@ -175,7 +176,6 @@
 
  public:
     // tags
- //typedef ::boost::mpl::true_ composite_state;
     typedef int composite_tag;
 
     // in case someone needs to know
@@ -228,7 +228,7 @@
         }
         exit_pt():m_forward(){}
         // by assignments, we keep our forwarding functor unchanged as our containing SM did not change
- template <class RHS>
+ template <class RHS>
         exit_pt(RHS& rhs):m_forward(){}
         exit_pt<ExitPoint>& operator= (const exit_pt<ExitPoint>& )
         {
@@ -684,7 +684,10 @@
         // if a guard condition is here, call it to check that the event is accepted
         static bool check_guard(library_sm& fsm,transition_event const& evt)
         {
- if ( ROW::guard_call(fsm,evt,fsm,fsm,fsm.m_substate_list) )
+ if ( ROW::guard_call(fsm,evt,
+ ::boost::fusion::at_key<StateType>(fsm.m_substate_list),
+ ::boost::fusion::at_key<StateType>(fsm.m_substate_list),
+ fsm.m_substate_list) )
                 return true;
             return false;
         }
@@ -698,7 +701,10 @@
             }
 
             // then call the action method
- ROW::action_call(fsm,evt,fsm,fsm,fsm.m_substate_list);
+ ROW::action_call(fsm,evt,
+ ::boost::fusion::at_key<StateType>(fsm.m_substate_list),
+ ::boost::fusion::at_key<StateType>(fsm.m_substate_list),
+ fsm.m_substate_list);
             return HANDLED_TRUE;
         }
     };
@@ -716,7 +722,10 @@
         static HandledEnum execute(library_sm& fsm, int region_index, int state, transition_event const& evt)
         {
             // then call the action method
- ROW::action_call(fsm,evt,fsm,fsm,fsm.m_substate_list);
+ ROW::action_call(fsm,evt,
+ ::boost::fusion::at_key<StateType>(fsm.m_substate_list),
+ ::boost::fusion::at_key<StateType>(fsm.m_substate_list),
+ fsm.m_substate_list);
             return HANDLED_TRUE;
         }
     };
@@ -733,7 +742,10 @@
         // if a guard condition is here, call it to check that the event is accepted
         static bool check_guard(library_sm& fsm,transition_event const& evt)
         {
- if ( ROW::guard_call(fsm,evt,fsm,fsm,fsm.m_substate_list) )
+ if ( ROW::guard_call(fsm,evt,
+ ::boost::fusion::at_key<StateType>(fsm.m_substate_list),
+ ::boost::fusion::at_key<StateType>(fsm.m_substate_list),
+ fsm.m_substate_list) )
                 return true;
             return false;
         }
@@ -792,37 +804,37 @@
     {
         typedef g_row_<Transition> type;
     };
- template <class Transition,class StateType>
+ template <class Transition,class StateType>
     struct create_backend_stt<a_row_tag,Transition,StateType>
     {
         typedef a_row_<Transition> type;
     };
- template <class Transition,class StateType>
+ template <class Transition,class StateType>
     struct create_backend_stt<_row_tag,Transition,StateType>
     {
         typedef _row_<Transition> type;
     };
- template <class Transition,class StateType>
- struct create_backend_stt<row_tag,Transition,StateType>
- {
- typedef row_<Transition> type;
- };
+ template <class Transition,class StateType>
+ struct create_backend_stt<row_tag,Transition,StateType>
+ {
+ typedef row_<Transition> type;
+ };
     // internal transitions
     template <class Transition,class StateType>
     struct create_backend_stt<g_irow_tag,Transition,StateType>
     {
         typedef g_irow_<Transition> type;
     };
- template <class Transition,class StateType>
+ template <class Transition,class StateType>
     struct create_backend_stt<a_irow_tag,Transition,StateType>
     {
         typedef a_irow_<Transition> type;
     };
- template <class Transition,class StateType>
- struct create_backend_stt<irow_tag,Transition,StateType>
- {
- typedef irow_<Transition> type;
- };
+ template <class Transition,class StateType>
+ struct create_backend_stt<irow_tag,Transition,StateType>
+ {
+ typedef irow_<Transition> type;
+ };
     template <class Transition,class StateType>
     struct create_backend_stt<_irow_tag,Transition,StateType>
     {
@@ -859,22 +871,22 @@
     struct create_real_stt
     {
         //typedef typename BaseType::transition_table stt_simulated;
- typedef typename ::boost::mpl::fold<
- stt_simulated,mpl::vector0<>,
+ typedef typename ::boost::mpl::fold<
+ stt_simulated,mpl::vector0<>,
             ::boost::mpl::push_back< ::boost::mpl::placeholders::_1,
                                      make_row_tag< ::boost::mpl::placeholders::_2 , BaseType > >
- >::type type;
+ >::type type;
     };
 
- template <class Table,class Intermediate,class StateType>
- struct add_forwarding_row_helper
- {
- typedef typename generate_event_set<Table>::type all_events;
- typedef typename ::boost::mpl::fold<
- all_events, Intermediate,
- ::boost::mpl::push_back< ::boost::mpl::placeholders::_1,
- frow<StateType, ::boost::mpl::placeholders::_2> > >::type type;
- };
+ template <class Table,class Intermediate,class StateType>
+ struct add_forwarding_row_helper
+ {
+ typedef typename generate_event_set<Table>::type all_events;
+ typedef typename ::boost::mpl::fold<
+ all_events, Intermediate,
+ ::boost::mpl::push_back< ::boost::mpl::placeholders::_1,
+ frow<StateType, ::boost::mpl::placeholders::_2> > >::type type;
+ };
     // gets the transition table from a composite and make from it a forwarding row
     template <class StateType,class IsComposite>
     struct get_internal_transition_table
@@ -886,18 +898,18 @@
         // Note: these are added first because they must have a lesser prio
         // than the deeper transitions in the sub regions
         typedef typename StateType::internal_transition_table istt_simulated;
- typedef typename ::boost::mpl::fold<
- istt_simulated,::boost::mpl::vector0<>,
+ typedef typename ::boost::mpl::fold<
+ istt_simulated,::boost::mpl::vector0<>,
             ::boost::mpl::push_back< ::boost::mpl::placeholders::_1,
                                      make_row_tag< ::boost::mpl::placeholders::_2 , StateType> >
- >::type intermediate;
+ >::type intermediate;
 
         // and add for every event a forwarding row
- typedef typename ::boost::mpl::eval_if<
- typename CompilePolicy::add_forwarding_rows,
- add_forwarding_row_helper<original_table,intermediate,StateType>,
- ::boost::mpl::identity<intermediate>
- >::type type;
+ typedef typename ::boost::mpl::eval_if<
+ typename CompilePolicy::add_forwarding_rows,
+ add_forwarding_row_helper<original_table,intermediate,StateType>,
+ ::boost::mpl::identity<intermediate>
+ >::type type;
     };
     template <class StateType>
     struct get_internal_transition_table<StateType, ::boost::mpl::false_ >
@@ -921,14 +933,14 @@
         typedef typename Composite::stt Stt;
         // for every state, add its transition table (if any)
         // transformed as frow
- typedef typename ::boost::mpl::fold<state_list,Stt,
- ::boost::mpl::insert_range<
+ typedef typename ::boost::mpl::fold<state_list,Stt,
+ ::boost::mpl::insert_range<
                         ::boost::mpl::placeholders::_1,
                         ::boost::mpl::end< ::boost::mpl::placeholders::_1>,
- get_internal_transition_table<
+ get_internal_transition_table<
                                 ::boost::mpl::placeholders::_2,
                                 is_composite_state< ::boost::mpl::placeholders::_2> > >
- >::type type;
+ >::type type;
     };
     // extend the table with tables from composite states
     typedef typename extend_table<library_sm>::type complete_table;
@@ -1051,7 +1063,7 @@
     get_state(::boost::msm::back::dummy<1> = 0)
     {
         return ::boost::fusion::at_key<typename ::boost::remove_reference<State>::type>(m_substate_list);
- }
+ }
 
     // checks if a flag is active using the BinaryOp as folding function
     template <class Flag,class BinaryOp>
@@ -1066,7 +1078,7 @@
                     ::boost::bind(::boost::msm::back::deref<flag_handler>(),
                         ::boost::bind(::boost::msm::back::plus2<flag_handler*,int>(),
                         flags_entries, _2)),
- ::boost::ref(*this)), _1));
+ ::boost::ref(*this)), _1));
     }
     // checks if a flag is active using no binary op if 1 region, or OR if > 1 regions
     template <class Flag>
@@ -1129,10 +1141,10 @@
      public:
      // Construct with the default initial states
      state_machine<Derived,HistoryPolicy,CompilePolicy >()
- :Derived()
- ,m_events_queue()
- ,m_deferred_events_queue()
- ,m_history()
+ :Derived()
+ ,m_events_queue()
+ ,m_deferred_events_queue()
+ ,m_history()
          ,m_event_processing(false)
          ,m_is_included(false)
          ,m_visitors()
@@ -1153,9 +1165,9 @@
         state_machine<Derived,HistoryPolicy,CompilePolicy \
>(BOOST_PP_ENUM(n, MSM_CONSTRUCTOR_HELPER_EXECUTE_SUB, ~ ) ) \
         :Derived(BOOST_PP_ENUM_PARAMS(n,t)) \
- ,m_events_queue() \
- ,m_deferred_events_queue() \
- ,m_history() \
+ ,m_events_queue() \
+ ,m_deferred_events_queue() \
+ ,m_history() \
          ,m_event_processing(false) \
          ,m_is_included(false) \
          ,m_visitors() \
@@ -1432,8 +1444,8 @@
         if (!handled && !is_contained() && !is_completion_event<Event>::type::value)
         {
             for (int i=0; i<nr_regions::value;++i)
- {
- no_transition(evt,*this,this->m_states[i]);
+ {
+ this->no_transition(evt,*this,this->m_states[i]);
             }
         }
         return handled;
@@ -1445,7 +1457,9 @@
     template <class Event>
     void no_action(Event const&){}
 
- HandledEnum process_any_event( ::boost::any const& evt);
+#ifndef BOOST_NO_RTTI
+ HandledEnum process_any_event( ::boost::any const& evt);
+#endif
 
 private:
     // composite accept implementation. First calls accept on the composite, then accept on all its active states.
@@ -1467,21 +1481,21 @@
 #undef MSM_COMPOSITE_ACCEPT_EXECUTE
 #undef MSM_COMPOSITE_ACCEPT_SUB
 
- // helper used to call the init states at the start of the state machine
+ // helper used to call the init states at the start of the state machine
     template <class Event>
- struct call_init
- {
- call_init(Event const& an_event,library_sm* self_):
+ struct call_init
+ {
+ call_init(Event const& an_event,library_sm* self_):
                 evt(an_event),self(self_){}
- template <class State>
- void operator()(boost::msm::wrap<State> const&)
- {
+ template <class State>
+ void operator()(boost::msm::wrap<State> const&)
+ {
             execute_entry(::boost::fusion::at_key<State>(self->m_substate_list),evt,*self);
- }
- private:
+ }
+ private:
         Event const& evt;
         library_sm* self;
- };
+ };
     // helper for flag handling. Uses OR by default on orthogonal zones.
     template <class Flag,bool orthogonalStates>
     struct FlagHelper
@@ -1516,7 +1530,7 @@
         }
         static bool forward(library_sm& fsm)
         {
- return ::boost::fusion::at_key<StateType>(fsm.m_substate_list).is_flag_active<Flag>();
+ return ::boost::fusion::at_key<StateType>(fsm.m_substate_list).template is_flag_active<Flag>();
         }
     };
     template <class Flag>
@@ -1580,7 +1594,7 @@
         // build a state list
         ::boost::mpl::for_each<state_list, boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                         (init_flags<Flag>(flags_entries));
- return flags_entries;
+ return flags_entries;
     }
 
     // helper used to create a state using the correct constructor
@@ -1589,7 +1603,7 @@
     {
         static void set_sm(library_sm* )
         {
- // state doesn't need its sm
+ // state doesn't need its sm
         }
     };
     // create a state requiring a pointer to the state machine
@@ -1598,8 +1612,8 @@
     {
         static void set_sm(library_sm* sm)
         {
- // create and set the fsm
- ::boost::fusion::at_key<State>(sm->m_substate_list).set_sm_ptr(sm);
+ // create and set the fsm
+ ::boost::fusion::at_key<State>(sm->m_substate_list).set_sm_ptr(sm);
         }
     };
         // main unspecialized helper class
@@ -1642,13 +1656,13 @@
         m_is_included=true;
         ::boost::fusion::for_each(m_substate_list,add_state<ContainingSM>(this,sm));
     }
- // A function object for use with mpl::for_each that stuffs
+ // A function object for use with mpl::for_each that stuffs
     // states into the state list.
     template<class ContainingSM>
     struct add_state
     {
         add_state(library_sm* self_,ContainingSM* sm)
- : self(self_),containing_sm(sm){}
+ : self(self_),containing_sm(sm){}
 
         // State is a sub fsm with exit pseudo states and gets a pointer to this fsm, so it can build a callback
         template <class StateType>
@@ -1659,7 +1673,7 @@
             ::boost::fusion::at_key<StateType>(self->m_substate_list).set_containing_sm(containing_sm);
         }
         // State is a sub fsm without exit pseudo states and does not get a callback to this fsm
- // or state is a normal state and needs nothing except creation
+ // or state is a normal state and needs nothing except creation
         template <class StateType>
         typename ::boost::enable_if<
             typename boost::mpl::and_<typename boost::mpl::not_
@@ -1742,7 +1756,7 @@
              // nothing to do
          }
 
- library_sm* m_sm;
+ library_sm* m_sm;
      };
      // helper to copy the active states attribute
      template <class region_id,int Dummy=0>
@@ -1841,7 +1855,7 @@
          static void do_start(library_sm*,Event const& ){}
      };
      // start for states machines which are themselves embedded in other state machines (composites)
- template <class Event>
+ template <class Event>
      void start(Event const& incomingEvent)
      {
          region_start_helper< ::boost::mpl::int_<0> >::template do_start(this,incomingEvent);
@@ -1852,16 +1866,16 @@
      {
          direct_event_start_helper(library_sm* self_):self(self_){}
          // this variant is for the standard case, entry due to activation of the containing FSM
- template <class EventType>
+ template <class EventType,class FsmType>
          typename ::boost::disable_if<typename has_direct_entry<EventType>::type,void>::type
- operator()(EventType const& evt, ::boost::msm::back::dummy<0> = 0)
+ operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<0> = 0)
          {
- (static_cast<Derived*>(self))->on_entry(evt,*self);
+ (static_cast<Derived*>(self))->on_entry(evt,fsm);
              self->start(evt);
          }
 
          // this variant is for the direct entry case (just one entry, not a sequence of entries)
- template <class EventType>
+ template <class EventType,class FsmType>
          typename ::boost::enable_if<
              typename ::boost::mpl::and_<
                         typename ::boost::mpl::not_< typename is_pseudo_entry<
@@ -1871,9 +1885,9 @@
                                                             <typename EventType::active_state>::type >::type
>::type>::type,void
>::type
- operator()(EventType const& evt, ::boost::msm::back::dummy<1> = 0)
+ operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<1> = 0)
          {
- (static_cast<Derived*>(self))->on_entry(evt,*self);
+ (static_cast<Derived*>(self))->on_entry(evt,fsm);
              int state_id = get_state_id<stt,typename EventType::active_state>::value;
              BOOST_STATIC_ASSERT(EventType::active_state::zone_index >= 0);
              BOOST_STATIC_ASSERT(EventType::active_state::zone_index <= nr_regions::value);
@@ -1883,7 +1897,7 @@
          }
 
          // this variant is for the fork entry case (a sequence on entries)
- template <class EventType>
+ template <class EventType,class FsmType>
          typename ::boost::enable_if<
              typename ::boost::mpl::and_<
                     typename ::boost::mpl::not_<
@@ -1893,9 +1907,9 @@
                                                                 typename EventType::active_state>::type
>::type>::type,void
>::type
- operator()(EventType const& evt, ::boost::msm::back::dummy<2> = 0)
+ operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<2> = 0)
          {
- (static_cast<Derived*>(self))->on_entry(evt,*self);
+ (static_cast<Derived*>(self))->on_entry(evt,fsm);
              ::boost::mpl::for_each<typename EventType::active_state,
                                     ::boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                                                         (fork_helper<EventType>(self,evt));
@@ -1904,14 +1918,14 @@
          }
 
          // this variant is for the pseudo state entry case
- template <class EventType>
+ template <class EventType,class FsmType>
          typename ::boost::enable_if<
              typename is_pseudo_entry<typename EventType::active_state >::type,void
>::type
- operator()(EventType const& evt, ::boost::msm::back::dummy<3> = 0)
+ operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<3> = 0)
          {
              // entry on the FSM
- (static_cast<Derived*>(self))->on_entry(evt,*self);
+ (static_cast<Derived*>(self))->on_entry(evt,fsm);
              int state_id = get_state_id<stt,typename EventType::active_state>::value;
              // given region starts with the entry pseudo state as active state
              self->m_states[EventType::active_state::zone_index] = state_id;
@@ -1973,27 +1987,27 @@
          static void do_exit(library_sm*,Event const& ){}
      };
      // entry/exit for states machines which are themselves embedded in other state machines (composites)
- template <class Event>
- void do_entry(Event const& incomingEvent)
+ template <class Event,class FsmType>
+ void do_entry(Event const& incomingEvent,FsmType& fsm)
      {
         // by default we activate the history/init states, can be overwritten by direct_event_start_helper
         region_entry_exit_helper< ::boost::mpl::int_<0> >::template do_entry(this,incomingEvent);
         // block immediate handling of events
         m_event_processing = true;
         // if the event is generating a direct entry/fork, set the current state(s) to the direct state(s)
- direct_event_start_helper(this)(incomingEvent);
+ direct_event_start_helper(this)(incomingEvent,fsm);
         // handle messages which were generated and blocked in the init calls
         m_event_processing = false;
         process_message_queue(this);
      }
- template <class Event>
- void do_exit(Event const& incomingEvent)
+ template <class Event,class FsmType>
+ void do_exit(Event const& incomingEvent,FsmType& fsm)
      {
         // first recursively exit the sub machines
         // forward the event for handling by sub state machines
         region_entry_exit_helper< ::boost::mpl::int_<0> >::template do_exit(this,incomingEvent);
         // then call our own exit
- (static_cast<Derived*>(this))->on_exit(incomingEvent,*this);
+ (static_cast<Derived*>(this))->on_exit(incomingEvent,fsm);
         // give the history a chance to handle this (or not).
         m_history.history_exit(this->m_states);
      }
@@ -2052,7 +2066,7 @@
         execute_entry(StateType& astate,EventType const& evt,FsmType& fsm,boost::msm::back::dummy<0> = 0)
     {
         // calls on_entry on the fsm then handles direct entries, fork, entry pseudo state
- astate.do_entry(evt);
+ astate.do_entry(evt,fsm);
     }
     // variant for states
     template <class StateType,class EventType,class FsmType>
@@ -2079,9 +2093,9 @@
     template <class StateType,class EventType,class FsmType>
     static
         typename ::boost::enable_if<typename is_composite_state<StateType>::type,void >::type
- execute_exit(StateType& astate,EventType const& evt,FsmType& , ::boost::msm::back::dummy<0> = 0)
+ execute_exit(StateType& astate,EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<0> = 0)
     {
- astate.do_exit(evt);
+ astate.do_exit(evt,fsm);
     }
     template <class StateType,class EventType,class FsmType>
     static

Copied: branches/release/boost/msm/front/detail/common_states.hpp (from r62128, /trunk/boost/msm/front/detail/common_states.hpp)
==============================================================================
--- /trunk/boost/msm/front/detail/common_states.hpp (original)
+++ branches/release/boost/msm/front/detail/common_states.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -25,8 +25,8 @@
 {
     inherit_attributes():m_attributes(){}
     inherit_attributes(Attributes const& the_attributes):m_attributes(the_attributes){}
- // on the fly attribute creation capability
- typedef Attributes attributes_type;
+ // on the fly attribute creation capability
+ typedef Attributes attributes_type;
     template <class Index>
     typename ::boost::fusion::result_of::at_key<attributes_type,
                                                 Index>::type
@@ -39,7 +39,7 @@
     typename ::boost::add_const<
         typename ::boost::fusion::result_of::at_key<attributes_type,
                                                     Index>::type>::type
- get_attribute(Index const&)const
+ get_attribute(Index const&)const
     {
         return const_cast<
             typename ::boost::add_const<
@@ -49,16 +49,16 @@
     }
 
 private:
- // attributes
- Attributes m_attributes;
+ // attributes
+ Attributes m_attributes;
 };
 
 // the interface for all states. Defines entry and exit functions. Overwrite to implement for any state needing it.
 template<class USERBASE,class Attributes= ::boost::fusion::map<> >
 struct state_base : public inherit_attributes<Attributes>, USERBASE
 {
- typedef USERBASE user_state_base;
- typedef Attributes attributes_type;
+ typedef USERBASE user_state_base;
+ typedef Attributes attributes_type;
 
     // empty implementation for the states not wishing to define an entry condition
     // will not be called polymorphic way

Copied: branches/release/boost/msm/front/euml/common.hpp (from r62128, /trunk/boost/msm/front/euml/common.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/common.hpp (original)
+++ branches/release/boost/msm/front/euml/common.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -135,12 +135,12 @@
 template <class T,class EVT,class FSM,class SourceState,class TargetState>
 struct get_result_type
 {
- typedef typename T::template transition_action_result<EVT,FSM,SourceState,TargetState>::type type;
+ typedef typename T::template transition_action_result<EVT,FSM,SourceState,TargetState>::type type;
 };
 template <class T,class Event,class FSM,class STATE>
 struct get_result_type2
 {
- typedef typename T::template state_action_result<Event,FSM,STATE>::type type;
+ typedef typename T::template state_action_result<Event,FSM,STATE>::type type;
 };
 template<class SEQ>
 struct get_sequence
@@ -316,7 +316,7 @@
 template <class ROW>
 struct make_vector_one_row
 {
- typedef boost::mpl::vector<ROW> type;
+ typedef boost::mpl::vector<ROW> type;
 };
 template <class T>
 T make_T(T t) {return t;}
@@ -369,29 +369,29 @@
     };
     typedef ::boost::mpl::set<action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& ,FSM& ,SourceState& src,TargetState&)const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& ,FSM& ,SourceState& src,TargetState&)const
+ {
         return src.get_attribute(Index());
- }
+ }
 };
 template<>
 struct GetSource_<void> : euml_action<GetSource_<void> >
 {
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef SourceState& type;
- };
- typedef ::boost::mpl::set<action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& , FSM&,SourceState& src,TargetState& )const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef SourceState& type;
+ };
+ typedef ::boost::mpl::set<action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& , FSM&,SourceState& src,TargetState& )const
+ {
         return src;
- }
+ }
 };
 struct get_source_tag {};
 struct GetSource_Helper: proto::extends< proto::terminal<get_source_tag>::type, GetSource_Helper, sm_domain>
@@ -419,29 +419,29 @@
     };
     typedef ::boost::mpl::set<action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& ,FSM& ,SourceState& ,TargetState& tgt)const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& ,FSM& ,SourceState& ,TargetState& tgt)const
+ {
         return tgt.get_attribute(Index());
- }
+ }
 };
 template<>
 struct GetTarget_<void> : euml_action<GetTarget_<void> >
 {
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef TargetState& type;
- };
- typedef ::boost::mpl::set<action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& , FSM&,SourceState& ,TargetState& tgt)const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef TargetState& type;
+ };
+ typedef ::boost::mpl::set<action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& , FSM&,SourceState& ,TargetState& tgt)const
+ {
         return tgt;
- }
+ }
 };
 struct get_target_tag {};
 struct GetTarget_Helper: proto::extends< proto::terminal<get_target_tag>::type, GetTarget_Helper, sm_domain>
@@ -472,28 +472,28 @@
     template <class Event,class FSM,class STATE>
     typename state_action_result<Event,FSM,STATE>::type
         operator()(Event const&,FSM& ,STATE& state )
- {
+ {
         return state.get_attribute(Index());
- }
+ }
 };
 template<>
 struct GetState_<void> : euml_action<GetState_<void> >
 {
     using euml_action<GetState_ >::operator=;
 
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef STATE& type;
- };
- typedef ::boost::mpl::set<state_action_tag> tag_type;
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef STATE& type;
+ };
+ typedef ::boost::mpl::set<state_action_tag> tag_type;
 
- template <class Event,class FSM,class STATE>
+ template <class Event,class FSM,class STATE>
     typename state_action_result<Event,FSM,STATE>::type
      operator()(Event const&,FSM& ,STATE& state )
- {
+ {
         return state;
- }
+ }
 };
 struct get_state_tag {};
 struct GetState_Helper: proto::extends< proto::terminal<get_state_tag>::type, GetState_Helper, sm_domain>
@@ -529,46 +529,46 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class Event,class FSM,class STATE>
- typename state_action_result<Event,FSM,STATE>::type
- operator()(Event const& evt,FSM& ,STATE& )
- {
- return evt.get_attribute(Index());
- }
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const
- {
+ template <class Event,class FSM,class STATE>
+ typename state_action_result<Event,FSM,STATE>::type
+ operator()(Event const& evt,FSM& ,STATE& )
+ {
+ return evt.get_attribute(Index());
+ }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const
+ {
         return evt.get_attribute(Index());
- }
+ }
 };
 template <>
 struct GetEvent_<void> : euml_action<GetEvent_<void> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef Event const& type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef EVT const& type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class Event,class FSM,class STATE>
- typename state_action_result<Event,FSM,STATE>::type
- operator()(Event const& evt,FSM& ,STATE& )
- {
- return evt;
- }
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const
- {
- return evt;
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef Event const& type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef EVT const& type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class Event,class FSM,class STATE>
+ typename state_action_result<Event,FSM,STATE>::type
+ operator()(Event const& evt,FSM& ,STATE& )
+ {
+ return evt;
+ }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const
+ {
+ return evt;
+ }
 };
 struct get_event_tag {};
 struct GetEvent_Helper: proto::extends< proto::terminal<get_event_tag>::type, GetEvent_Helper, sm_domain>
@@ -608,12 +608,12 @@
     {
         return fsm.get_attribute(Index());
     }
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState&)const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState&)const
+ {
         return fsm.get_attribute(Index());
- }
+ }
 };
 template<>
 struct GetFsm_<void> : euml_action<GetFsm_<void> >
@@ -739,7 +739,7 @@
     template <class Event,class FSM,class STATE >
     struct state_action_result
     {
- typedef typename
+ typedef typename
             ::boost::fusion::result_of::at_key<
             typename get_attributes_type<
                     typename ::boost::remove_reference<
@@ -749,7 +749,7 @@
     template <class EVT,class FSM,class SourceState,class TargetState>
     struct transition_action_result
     {
- typedef typename
+ typedef typename
             ::boost::fusion::result_of::at_key<
             typename get_attributes_type<
                     typename ::boost::remove_reference<
@@ -760,19 +760,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Target::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Target::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Target()(evt,fsm,src,tgt)).get_attribute(Index());
     }
     template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Target::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Target::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Target()(evt,fsm,state)).get_attribute(Index());
@@ -800,117 +800,117 @@
 struct Source_ : euml_action<Source_<Index> >
 {
     using euml_action<Source_<Index> >::operator=;
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename
- ::boost::fusion::result_of::at_key<typename SourceState::attributes_type,
- Index >::type type;
- };
- typedef ::boost::mpl::set<action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& , FSM&,SourceState& src,TargetState& )const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename
+ ::boost::fusion::result_of::at_key<typename SourceState::attributes_type,
+ Index >::type type;
+ };
+ typedef ::boost::mpl::set<action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& , FSM&,SourceState& src,TargetState& )const
+ {
         return src.get_attribute(Index());
- }
+ }
 };
 template <class Index>
 struct Target_ : euml_action<Target_<Index> >
 {
     using euml_action<Target_<Index> >::operator=;
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename
- ::boost::fusion::result_of::at_key<typename TargetState::attributes_type,
- Index >::type type;
- };
- typedef ::boost::mpl::set<action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& ,FSM& ,SourceState& ,TargetState& tgt)const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename
+ ::boost::fusion::result_of::at_key<typename TargetState::attributes_type,
+ Index >::type type;
+ };
+ typedef ::boost::mpl::set<action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& ,FSM& ,SourceState& ,TargetState& tgt)const
+ {
         return tgt.get_attribute(Index());
- }
+ }
 };
 template <class Index>
 struct State_ : euml_action<State_<Index> >
 {
     using euml_action<State_<Index> >::operator=;
 
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename
- ::boost::fusion::result_of::at_key<typename STATE::attributes_type,
- Index >::type type;
- };
- typedef ::boost::mpl::set<state_action_tag> tag_type;
-
- template <class Event,class FSM,class STATE>
- typename state_action_result<Event,FSM,STATE>::type
- operator()(Event const&,FSM& ,STATE& state )
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename
+ ::boost::fusion::result_of::at_key<typename STATE::attributes_type,
+ Index >::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag> tag_type;
+
+ template <class Event,class FSM,class STATE>
+ typename state_action_result<Event,FSM,STATE>::type
+ operator()(Event const&,FSM& ,STATE& state )
+ {
         return state.get_attribute(Index());
- }
+ }
 };
 template <class Index>
 struct Event_ : euml_action<Event_<Index> >
 {
     using euml_action<Event_<Index> >::operator=;
 
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename ::boost::add_const<
- typename ::boost::fusion::result_of::at_key<typename Event::attributes_type,
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename ::boost::add_const<
+ typename ::boost::fusion::result_of::at_key<typename Event::attributes_type,
                                                         Index >::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename ::boost::add_const<
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename ::boost::add_const<
             typename ::boost::fusion::result_of::at_key<typename EVT::attributes_type,
                                                         Index >::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class Event,class FSM,class STATE>
- typename state_action_result<Event,FSM,STATE>::type
- operator()(Event const& evt,FSM& ,STATE& )
- {
- return evt.get_attribute(Index());
- }
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
- operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const
- {
- return evt.get_attribute(Index());
- }
+ template <class Event,class FSM,class STATE>
+ typename state_action_result<Event,FSM,STATE>::type
+ operator()(Event const& evt,FSM& ,STATE& )
+ {
+ return evt.get_attribute(Index());
+ }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const
+ {
+ return evt.get_attribute(Index());
+ }
 };
 template <class StateType,class Index>
 struct State_Attribute_ : euml_action<State_Attribute_<StateType,Index> >
 {
     using euml_action<State_Attribute_<StateType,Index> >::operator=;
 
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename
- ::boost::fusion::result_of::at_key<typename StateType::attributes_type,
- Index >::type type;
- };
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename
+ ::boost::fusion::result_of::at_key<typename StateType::attributes_type,
+ Index >::type type;
+ };
     typedef ::boost::mpl::set<state_action_tag> tag_type;
 
- template <class Event,class FSM,class STATE>
- typename state_action_result<Event,FSM,STATE>::type
- operator()(Event const&,FSM& fsm,STATE& )
- {
+ template <class Event,class FSM,class STATE>
+ typename state_action_result<Event,FSM,STATE>::type
+ operator()(Event const&,FSM& fsm,STATE& )
+ {
         return fsm.template get_state<StateType&>().get_attribute(Index());
- }
+ }
 };
 
 template <class Index>
@@ -974,7 +974,7 @@
     {
         return true;
     }
-};
+};
 True_ const true_;
 
 struct False_ : euml::euml_action<False_>
@@ -2066,7 +2066,7 @@
         struct function_name ## tag{}; \
         struct functor ## Helper : proto::extends< proto::terminal< function_name ## tag >::type, \
         functor ## Helper , sm_domain> { template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5> \
- struct In {typedef functor <Arg1,Arg2,Arg3,Arg4,Arg5> type;}; }; \
+ struct In {typedef functor <Arg1,Arg2,Arg3,Arg4,Arg5> type;}; }; \
         functor ## Helper const function_name ;
 
 #define BOOST_MSM_EUML_METHOD(functor,function,function_name,result_trans,result_state) \
@@ -2191,7 +2191,7 @@
         struct function_name ## tag{}; \
         struct functor ## Helper : proto::extends< proto::terminal< function_name ## tag >::type, \
         functor ## Helper , sm_domain> { template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5> \
- struct In {typedef functor <Arg1,Arg2,Arg3,Arg4,Arg5> type;}; }; \
+ struct In {typedef functor <Arg1,Arg2,Arg3,Arg4,Arg5> type;}; }; \
         functor ## Helper const function_name ;
 
 #endif

Copied: branches/release/boost/msm/front/euml/container.hpp (from r62128, /trunk/boost/msm/front/euml/container.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/container.hpp (original)
+++ branches/release/boost/msm/front/euml/container.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -45,23 +45,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).front();
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).front();
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).front();
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).front();
+ }
 };
 
 struct front_tag {};
@@ -99,23 +99,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).back();
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).back();
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).back();
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).back();
+ }
 };
 
 struct back_tag {};
@@ -153,23 +153,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).begin();
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).begin();
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).begin();
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).begin();
+ }
 };
 
 struct begin_tag {};
@@ -207,23 +207,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).end();
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).end();
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).end();
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).end();
+ }
 };
 struct end_tag {};
 struct End_Helper: proto::extends< proto::terminal<end_tag>::type, End_Helper, sm_domain>
@@ -260,23 +260,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).rbegin();
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).rbegin();
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).rbegin();
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).rbegin();
+ }
 };
 
 struct rbegin_tag {};
@@ -314,23 +314,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).rend();
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).rend();
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).rend();
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).rend();
+ }
 };
 struct rend_tag {};
 struct REnd_Helper: proto::extends< proto::terminal<rend_tag>::type, REnd_Helper, sm_domain>
@@ -751,19 +751,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).capacity();
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).capacity();
@@ -804,19 +804,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).size();
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).size();
@@ -857,19 +857,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).max_size();
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).max_size();
@@ -1053,17 +1053,17 @@
 
     // version for transition + second param not an iterator (meaning that, Container is not an associative container)
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
+ typename ::boost::enable_if<
         typename ::boost::mpl::and_<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
                 typename ::boost::mpl::not_<
                     typename has_iterator_category<
                         typename Param2::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
>::type
>::type
>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
>::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
@@ -1072,15 +1072,15 @@
 
     // version for transition + second param is an iterator (meaning that, Container is an associative container)
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
+ typename ::boost::enable_if<
         typename ::boost::mpl::and_<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
                     typename has_iterator_category<
                         typename Param2::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
>::type
>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
>::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
@@ -1088,18 +1088,18 @@
     }
 
     // version for state action + second param not an iterator (meaning that, Container is not an associative container)
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
         typename ::boost::mpl::and_<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
                 typename ::boost::mpl::not_<
                     typename has_iterator_category<
                         typename Param2::template state_action_result<Event,FSM,STATE>::type
>::type
>::type
>::type,
- typename state_action_result<Event,FSM,STATE>::type
+ typename state_action_result<Event,FSM,STATE>::type
>::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
@@ -1107,16 +1107,16 @@
     }
 
     // version for state action + second param is an iterator (meaning that, Container is an associative container)
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
         typename ::boost::mpl::and_<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
                     typename has_iterator_category<
                         typename Param2::template state_action_result<Event,FSM,STATE>::type
>::type
>::type,
- typename state_action_result<Event,FSM,STATE>::type
+ typename state_action_result<Event,FSM,STATE>::type
>::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
@@ -1148,19 +1148,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state));
@@ -1238,19 +1238,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Iterator1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Iterator1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
     operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt));
     }
     template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Iterator1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Iterator1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
     operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state));
@@ -1274,19 +1274,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Iterator1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Iterator1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
     operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt),Iterator2()(evt,fsm,src,tgt));
     }
     template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Iterator1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Iterator1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
     operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state),Iterator2()(evt,fsm,state));
@@ -1515,19 +1515,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
@@ -2445,19 +2445,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
@@ -2488,15 +2488,15 @@
 
     // version for transition + param is an iterator
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
+ typename ::boost::enable_if<
         typename ::boost::mpl::and_<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
                     typename has_iterator_category<
                         typename Param1::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
>::type
>::type,
- void
+ void
>::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
@@ -2504,16 +2504,16 @@
     }
 
     // version for state action + param is an iterator
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
         typename ::boost::mpl::and_<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
                     typename has_iterator_category<
                         typename Param1::template state_action_result<Event,FSM,STATE>::type
>::type
>::type,
- void
+ void
>::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
@@ -2522,17 +2522,17 @@
 
     // version for transition + param not an iterator
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
+ typename ::boost::enable_if<
         typename ::boost::mpl::and_<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
                 typename ::boost::mpl::not_<
                     typename has_iterator_category<
                         typename Param1::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
>::type
>::type
>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
>::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
@@ -2540,18 +2540,18 @@
     }
 
     // version for state action + param not an iterator
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
         typename ::boost::mpl::and_<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
                 typename ::boost::mpl::not_<
                     typename has_iterator_category<
                         typename Param1::template state_action_result<Event,FSM,STATE>::type
>::type
>::type
>::type,
- typename state_action_result<Event,FSM,STATE>::type
+ typename state_action_result<Event,FSM,STATE>::type
>::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
@@ -2595,23 +2595,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).find(Param()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).find(Param()(evt,fsm,state));
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).find(Param()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).find(Param()(evt,fsm,state));
+ }
 };
 
 struct associative_find_tag {};
@@ -2649,19 +2649,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).count(Param()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).count(Param()(evt,fsm,state));
@@ -2702,23 +2702,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).lower_bound(Param()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).lower_bound(Param()(evt,fsm,state));
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).lower_bound(Param()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).lower_bound(Param()(evt,fsm,state));
+ }
 };
 
 struct associative_lower_bound_tag {};
@@ -2757,23 +2757,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).upper_bound(Param()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).upper_bound(Param()(evt,fsm,state));
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).upper_bound(Param()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).upper_bound(Param()(evt,fsm,state));
+ }
 };
 
 struct associative_upper_bound_tag {};
@@ -2812,23 +2812,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).first;
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).first;
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).first;
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).first;
+ }
 };
 
 struct first_tag {};
@@ -2866,23 +2866,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).second;
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).second;
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).second;
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).second;
+ }
 };
 
 struct second_tag {};
@@ -2928,23 +2928,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T()(evt,fsm,src,tgt)).equal_range(Param()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T()(evt,fsm,state)).equal_range(Param()(evt,fsm,state));
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T()(evt,fsm,src,tgt)).equal_range(Param()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T()(evt,fsm,state)).equal_range(Param()(evt,fsm,state));
+ }
 };
 
 struct associative_equal_range_tag {};
@@ -3090,20 +3090,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
                                                       Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
@@ -3127,19 +3127,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state));
@@ -3163,19 +3163,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
@@ -3199,20 +3199,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
                                               Param3()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
@@ -3251,20 +3251,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).append (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
                                                       Param3()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).append (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
@@ -3288,19 +3288,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).append(Param1()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).append(Param1()(evt,fsm,state));
@@ -3324,19 +3324,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).append(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).append(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
@@ -3374,20 +3374,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
                                                      Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
@@ -3411,19 +3411,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
@@ -3446,20 +3446,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
                                                      Param3()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
@@ -3604,20 +3604,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).assign (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
                                                       Param3()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).assign (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
@@ -3642,19 +3642,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).assign(Param1()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).assign(Param1()(evt,fsm,state));
@@ -3678,19 +3678,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).assign(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).assign(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
@@ -3727,20 +3727,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).replace (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
                                                        Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).replace (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
@@ -3765,20 +3765,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).replace(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
                                                       Param3()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).replace(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
@@ -3823,19 +3823,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).c_str();
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).c_str();
@@ -3878,19 +3878,19 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return (Container()(evt,fsm,src,tgt)).data();
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Container::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Container::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return (Container()(evt,fsm,state)).data();

Copied: branches/release/boost/msm/front/euml/euml.hpp (from r62128, /trunk/boost/msm/front/euml/euml.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/euml.hpp (original)
+++ branches/release/boost/msm/front/euml/euml.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -17,4 +17,4 @@
 #include <boost/msm/front/euml/state_grammar.hpp>
 #include <boost/msm/front/euml/stt_grammar.hpp>
 
-#endif //BOOST_MSM_FRONT_EUML_EUML_H
\ No newline at end of file
+#endif //BOOST_MSM_FRONT_EUML_EUML_H

Copied: branches/release/boost/msm/front/euml/euml_typeof.hpp (from r62128, /trunk/boost/msm/front/euml/euml_typeof.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/euml_typeof.hpp (original)
+++ branches/release/boost/msm/front/euml/euml_typeof.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -118,4 +118,4 @@
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::EqualTo_, 2)
 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::NotEqualTo_, 2)
 
-#endif //BOOST_MSM_FRONT_EUML_TYPEOF_H
\ No newline at end of file
+#endif //BOOST_MSM_FRONT_EUML_TYPEOF_H

Copied: branches/release/boost/msm/front/euml/guard_grammar.hpp (from r62128, /trunk/boost/msm/front/euml/guard_grammar.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/guard_grammar.hpp (original)
+++ branches/release/boost/msm/front/euml/guard_grammar.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -22,246 +22,246 @@
 
 struct BuildGuardsCases
 {
- // The primary template matches nothing:
- template<typename Tag>
- struct case_
- : proto::not_<proto::_>
- {};
+ // The primary template matches nothing:
+ template<typename Tag>
+ struct case_
+ : proto::not_<proto::_>
+ {};
 };
 template<>
 struct BuildGuardsCases::case_<proto::tag::logical_or>
- : proto::when<
+ : proto::when<
                     proto::logical_or<BuildGuards,BuildGuards >,
                     Or_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::logical_and>
- : proto::when<
+ : proto::when<
                     proto::logical_and<BuildGuards,BuildGuards >,
                     And_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::logical_not>
- : proto::when<
+ : proto::when<
                     proto::logical_not<BuildGuards >,
                     Not_<BuildGuards(proto::_child)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::less>
- : proto::when<
+ : proto::when<
                     proto::less<BuildGuards, BuildGuards >,
                     Less_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::less_equal>
- : proto::when<
+ : proto::when<
                     proto::less_equal<BuildGuards, BuildGuards >,
                     LessEqual_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::greater>
- : proto::when<
+ : proto::when<
                     proto::greater<BuildGuards, BuildGuards >,
                     Greater_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::greater_equal>
- : proto::when<
+ : proto::when<
                     proto::greater_equal<BuildGuards, BuildGuards >,
                     GreaterEqual_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::equal_to>
- : proto::when<
- proto::equal_to<BuildGuards, BuildGuards >,
- EqualTo_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+ : proto::when<
+ proto::equal_to<BuildGuards, BuildGuards >,
+ EqualTo_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::not_equal_to>
- : proto::when<
- proto::not_equal_to<BuildGuards, BuildGuards >,
- NotEqualTo_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+ : proto::when<
+ proto::not_equal_to<BuildGuards, BuildGuards >,
+ NotEqualTo_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::pre_inc>
- : proto::when<
+ : proto::when<
                     proto::pre_inc<BuildGuards >,
                     Pre_inc_<BuildGuards(proto::_child)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::dereference>
- : proto::when<
+ : proto::when<
                     proto::dereference<BuildGuards >,
                     Deref_<BuildGuards(proto::_child)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::pre_dec>
- : proto::when<
+ : proto::when<
                     proto::pre_dec<BuildGuards >,
                     Pre_dec_<BuildGuards(proto::_child)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::post_inc>
- : proto::when<
+ : proto::when<
                     proto::post_inc<BuildGuards >,
                     Post_inc_<BuildGuards(proto::_child)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::post_dec>
- : proto::when<
+ : proto::when<
                     proto::post_dec<BuildGuards >,
                     Post_dec_<BuildGuards(proto::_child)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::plus>
- : proto::when<
+ : proto::when<
                     proto::plus<BuildGuards,BuildGuards >,
                     Plus_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::minus>
- : proto::when<
+ : proto::when<
                     proto::minus<BuildGuards,BuildGuards >,
                     Minus_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::multiplies>
- : proto::when<
+ : proto::when<
                     proto::multiplies<BuildGuards,BuildGuards >,
                     Multiplies_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::divides>
- : proto::when<
+ : proto::when<
                     proto::divides<BuildGuards,BuildGuards >,
                     Divides_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::modulus>
- : proto::when<
+ : proto::when<
                     proto::modulus<BuildGuards,BuildGuards >,
                     Modulus_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::bitwise_and>
- : proto::when<
+ : proto::when<
                     proto::bitwise_and<BuildGuards,BuildGuards >,
                     Bitwise_And_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::bitwise_or>
- : proto::when<
+ : proto::when<
                     proto::bitwise_or<BuildGuards,BuildGuards >,
                     Bitwise_Or_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::subscript>
- : proto::when<
+ : proto::when<
                     proto::subscript<BuildGuards,BuildGuards >,
                     Subscript_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::plus_assign>
- : proto::when<
+ : proto::when<
                     proto::plus_assign<BuildGuards,BuildGuards >,
                     Plus_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::minus_assign>
- : proto::when<
+ : proto::when<
                     proto::minus_assign<BuildGuards,BuildGuards >,
                     Minus_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::multiplies_assign>
- : proto::when<
+ : proto::when<
                     proto::multiplies_assign<BuildGuards,BuildGuards >,
                     Multiplies_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::divides_assign>
- : proto::when<
+ : proto::when<
                     proto::divides_assign<BuildGuards,BuildGuards >,
                     Divides_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::modulus_assign>
- : proto::when<
+ : proto::when<
                     proto::modulus_assign<BuildGuards,BuildGuards >,
                     Modulus_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::shift_left_assign>
- : proto::when<
+ : proto::when<
                     proto::shift_left_assign<BuildGuards,BuildGuards >,
                     ShiftLeft_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::shift_right_assign>
- : proto::when<
+ : proto::when<
                     proto::shift_right_assign<BuildGuards,BuildGuards >,
                     ShiftRight_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::shift_left>
- : proto::when<
+ : proto::when<
                     proto::shift_left<BuildGuards,BuildGuards >,
                     ShiftLeft_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::shift_right>
- : proto::when<
+ : proto::when<
                     proto::shift_right<BuildGuards,BuildGuards >,
                     ShiftRight_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::assign>
- : proto::when<
+ : proto::when<
                     proto::assign<BuildGuards,BuildGuards >,
                     Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::bitwise_xor>
- : proto::when<
+ : proto::when<
                     proto::bitwise_xor<BuildGuards,BuildGuards >,
                     Bitwise_Xor_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
>
 {};
 template<>
 struct BuildGuardsCases::case_<proto::tag::negate>
- : proto::when<
+ : proto::when<
                     proto::negate<BuildGuards >,
                     Unary_Minus_<BuildGuards(proto::_child)>()
>
@@ -269,42 +269,42 @@
 
 template<>
 struct BuildGuardsCases::case_<proto::tag::function>
- : proto::or_<
- proto::when<
- proto::function<proto::terminal<if_tag>,BuildGuards,BuildGuards,BuildGuards >,
+ : proto::or_<
+ proto::when<
+ proto::function<proto::terminal<if_tag>,BuildGuards,BuildGuards,BuildGuards >,
                     If_Else_<BuildGuards(proto::_child_c<1>),
- BuildGuards(proto::_child_c<2>),
- BuildGuards(proto::_child_c<3>) >()
- >,
+ BuildGuards(proto::_child_c<2>),
+ BuildGuards(proto::_child_c<3>) >()
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_> >,
                     get_fct<proto::_child_c<0> >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions >,
                     get_fct<proto::_child_c<0>,BuildActions(proto::_child_c<1>) >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions >,
                     get_fct<proto::_child_c<0>,BuildActions(proto::_child_c<1>),BuildActions(proto::_child_c<2>) >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions,BuildActions >,
                     get_fct<proto::_child_c<0>,BuildActions(proto::_child_c<1>)
                                               ,BuildActions(proto::_child_c<2>),BuildActions(proto::_child_c<3>) >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions,BuildActions,BuildActions >,
                     get_fct<proto::_child_c<0>
                             ,BuildActions(proto::_child_c<1>),BuildActions(proto::_child_c<2>)
                             ,BuildActions(proto::_child_c<3>),BuildActions(proto::_child_c<4>) >()
- >,
- proto::when<
+ >,
+ proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions,BuildActions,BuildActions,BuildActions >,
                     get_fct<proto::_child_c<0>
                             ,BuildActions(proto::_child_c<1>),BuildActions(proto::_child_c<2>)
                             ,BuildActions(proto::_child_c<3>),BuildActions(proto::_child_c<4>),BuildActions(proto::_child_c<5>) >()
- >
+ >
 #ifdef BOOST_MSVC
             ,proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions,BuildActions,BuildActions,BuildActions,BuildActions >,
@@ -312,18 +312,18 @@
                             ,BuildActions(proto::_child_c<1>),BuildActions(proto::_child_c<2>)
                             ,BuildActions(proto::_child_c<3>),BuildActions(proto::_child_c<4>)
                             ,BuildActions(proto::_child_c<5>),BuildActions(proto::_child_c<6>) >()
- >
+ >
 #endif
>
 {};
 
 template<>
 struct BuildGuardsCases::case_<proto::tag::terminal>
- : proto::or_<
+ : proto::or_<
         proto::when <
- proto::terminal<action_tag>,
- get_action_name<proto::_ >()
- >,
+ proto::terminal<action_tag>,
+ get_action_name<proto::_ >()
+ >,
         proto::when<
                         proto::terminal<state_tag>,
                         proto::_
@@ -340,7 +340,7 @@
 {};
 
 struct BuildGuards
- : proto::switch_<BuildGuardsCases>
+ : proto::switch_<BuildGuardsCases>
 {};
 
 }}}}

Copied: branches/release/boost/msm/front/euml/operator.hpp (from r62128, /trunk/boost/msm/front/euml/operator.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/operator.hpp (original)
+++ branches/release/boost/msm/front/euml/operator.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -29,11 +29,11 @@
 template <class T1,class T2>
 struct Or_ : euml_action<Or_<T1,T2> >
 {
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
- {
- return (T1()(evt,fsm,src,tgt) || T2()(evt,fsm,src,tgt));
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
+ {
+ return (T1()(evt,fsm,src,tgt) || T2()(evt,fsm,src,tgt));
+ }
     template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)
     {
@@ -43,11 +43,11 @@
 template <class T1,class T2>
 struct And_ : euml_action<And_<T1,T2> >
 {
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
- {
- return (T1()(evt,fsm,src,tgt) && T2()(evt,fsm,src,tgt));
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
+ {
+ return (T1()(evt,fsm,src,tgt) && T2()(evt,fsm,src,tgt));
+ }
     template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)
     {
@@ -57,11 +57,11 @@
 template <class T1>
 struct Not_ : euml_action<Not_<T1> >
 {
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
- {
- return !(T1()(evt,fsm,src,tgt));
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
+ {
+ return !(T1()(evt,fsm,src,tgt));
+ }
     template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)
     {
@@ -89,32 +89,32 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Action1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- if (Condition()(evt,fsm,src,tgt))
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Action1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ if (Condition()(evt,fsm,src,tgt))
         {
             return Action1()(evt,fsm,src,tgt);
         }
         return Action2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Action1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Action1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
+ {
         if (Condition()(evt,fsm,state))
         {
             return Action1()(evt,fsm,state);
         }
         return Action2()(evt,fsm,state);
- }
+ }
 };
 
 template <class Condition,class Action1,class Action2>
@@ -134,24 +134,24 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- if (Condition()(evt,fsm,src,tgt))
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ if (Condition()(evt,fsm,src,tgt))
         {
             return Action1()(evt,fsm,src,tgt);
         }
         return Action2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
+ }
+ template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
+ {
         if (Condition()(evt,fsm,state))
         {
             return Action1()(evt,fsm,state);
         }
         return Action2()(evt,fsm,state);
- }
+ }
 };
 
 struct if_tag
@@ -192,30 +192,30 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Action1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Action1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
         if (Condition()(evt,fsm,src,tgt))
         {
             return Action1()(evt,fsm,src,tgt);
         }
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Action1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Action1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
+ {
         if (Condition()(evt,fsm,state))
         {
             return Action1()(evt,fsm,state);
         }
- }
+ }
 };
 
 template <class Condition,class Action1>
@@ -235,22 +235,22 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
         if (Condition()(evt,fsm,src,tgt))
         {
             return Action1()(evt,fsm,src,tgt);
         }
- }
- template <class Event,class FSM,class STATE>
+ }
+ template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
+ {
         if (Condition()(evt,fsm,state))
         {
             return Action1()(evt,fsm,state);
         }
- }
+ }
 };
 struct if_then_tag
 {
@@ -465,23 +465,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return *(T()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return *(T()(evt,fsm,state));
- }
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return *(T()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return *(T()(evt,fsm,state));
+ }
 };
 
 template <class T>
@@ -489,109 +489,109 @@
 {
     using euml_action<Pre_inc_<T> >::operator=;
 
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return ++T()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return ++T()(evt,fsm,state);
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return ++T()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return ++T()(evt,fsm,state);
+ }
 };
 template <class T>
 struct Pre_dec_ : euml_action<Pre_dec_<T> >
 {
     using euml_action<Pre_dec_<T> >::operator=;
 
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return --T()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return --T()(evt,fsm,state);
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return --T()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return --T()(evt,fsm,state);
+ }
 };
 template <class T>
 struct Post_inc_ : euml_action<Post_inc_<T> >
 {
     using euml_action<Post_inc_<T> >::operator=;
 
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename ::boost::remove_reference<
- typename get_result_type2<T,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename ::boost::remove_reference<
- typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T()(evt,fsm,src,tgt)++;
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T()(evt,fsm,state)++;
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename ::boost::remove_reference<
+ typename get_result_type2<T,Event,FSM,STATE>::type>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename ::boost::remove_reference<
+ typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T()(evt,fsm,src,tgt)++;
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T()(evt,fsm,state)++;
     }
 };
 template <class T>
@@ -599,804 +599,804 @@
 {
     using euml_action<Post_dec_<T> >::operator=;
 
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename ::boost::remove_reference<
- typename get_result_type2<T,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename ::boost::remove_reference<
- typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T()(evt,fsm,src,tgt)--;
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T()(evt,fsm,state)--;
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename ::boost::remove_reference<
+ typename get_result_type2<T,Event,FSM,STATE>::type>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename ::boost::remove_reference<
+ typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T()(evt,fsm,src,tgt)--;
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T()(evt,fsm,state)--;
+ }
 };
 
 template <class T1,class T2>
 struct Plus_ : euml_action<Plus_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)+T2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)+T2()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)+T2()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)+T2()(evt,fsm,state);
+ }
 };
 template <class T1,class T2>
 struct Minus_ : euml_action<Minus_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)-T2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)-T2()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)-T2()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)-T2()(evt,fsm,state);
+ }
 };
 template <class T1,class T2>
 struct Multiplies_ : euml_action<Multiplies_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)*T2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)*T2()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)*T2()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)*T2()(evt,fsm,state);
+ }
 };
 template <class T1,class T2>
 struct Divides_ : euml_action<Divides_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)/T2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)/T2()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)/T2()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)/T2()(evt,fsm,state);
+ }
 };
 template <class T1,class T2>
 struct Modulus_ : euml_action<Modulus_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)%T2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)%T2()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)%T2()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)%T2()(evt,fsm,state);
+ }
 };
 template <class T1,class T2>
 struct Bitwise_And_ : euml_action<Bitwise_And_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)&T2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)&T2()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)&T2()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)&T2()(evt,fsm,state);
+ }
 };
 template <class T1,class T2>
 struct Bitwise_Or_ : euml_action<Bitwise_Or_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)|T2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)|T2()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)|T2()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)|T2()(evt,fsm,state);
+ }
 };
 template <class T1,class T2>
 struct Bitwise_Xor_ : euml_action<Bitwise_Xor_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)^T2()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)^T2()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)^T2()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)^T2()(evt,fsm,state);
+ }
 };
 template <class T1,class T2>
 struct Subscript_ : euml_action<Subscript_<T1,T2> >
 {
- template <class T>
- struct get_reference
- {
- typedef typename T::reference type;
- };
- template <class T>
- struct get_mapped_type
- {
+ template <class T>
+ struct get_reference
+ {
+ typedef typename T::reference type;
+ };
+ template <class T>
+ struct get_mapped_type
+ {
         typedef typename T::value_type::second_type& type;
- };
+ };
     template <class Event,class FSM,class STATE >
     struct state_action_result
     {
- typedef typename ::boost::remove_reference<
- typename get_result_type2<T1,Event,FSM,STATE>::type>::type container_type;
- typedef typename ::boost::mpl::eval_if<
- typename has_key_type<container_type>::type,
- get_mapped_type<container_type>,
+ typedef typename ::boost::remove_reference<
+ typename get_result_type2<T1,Event,FSM,STATE>::type>::type container_type;
+ typedef typename ::boost::mpl::eval_if<
+ typename has_key_type<container_type>::type,
+ get_mapped_type<container_type>,
             ::boost::mpl::eval_if<
                 typename ::boost::is_pointer<container_type>::type,
                 ::boost::add_reference<typename ::boost::remove_pointer<container_type>::type >,
- get_reference<container_type>
+ get_reference<container_type>
>
>::type type;
     };
     template <class EVT,class FSM,class SourceState,class TargetState>
     struct transition_action_result
     {
- typedef typename ::boost::remove_reference<
- typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type container_type;
- typedef typename ::boost::mpl::eval_if<
- typename has_key_type<container_type>::type,
- get_mapped_type<container_type>,
+ typedef typename ::boost::remove_reference<
+ typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type container_type;
+ typedef typename ::boost::mpl::eval_if<
+ typename has_key_type<container_type>::type,
+ get_mapped_type<container_type>,
             ::boost::mpl::eval_if<
                 typename ::boost::is_pointer<container_type>::type,
                 ::boost::add_reference<typename ::boost::remove_pointer<container_type>::type >,
- get_reference<container_type>
+ get_reference<container_type>
>
>::type type;
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return T1()(evt,fsm,src,tgt)[T2()(evt,fsm,src,tgt)];
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return T1()(evt,fsm,state)[T2()(evt,fsm,state)];
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return T1()(evt,fsm,src,tgt)[T2()(evt,fsm,src,tgt)];
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return T1()(evt,fsm,state)[T2()(evt,fsm,state)];
+ }
 };
 template <class T1,class T2>
 struct Plus_Assign_ : euml_action<Plus_Assign_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)+=T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)+=T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)+=T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)+=T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct Minus_Assign_ : euml_action<Minus_Assign_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)-=T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)-=T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)-=T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)-=T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct Multiplies_Assign_ : euml_action<Multiplies_Assign_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)*=T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)*=T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)*=T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)*=T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct Divides_Assign_ : euml_action<Divides_Assign_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)/=T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)/=T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)/=T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)/=T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct Modulus_Assign_ : euml_action<Modulus_Assign_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)%=T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)%=T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)%=T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)%=T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct ShiftLeft_Assign_ : euml_action<ShiftLeft_Assign_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)<<=T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)<<=T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)<<=T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)<<=T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct ShiftRight_Assign_ : euml_action<ShiftRight_Assign_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)>>=T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)>>=T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)>>=T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)>>=T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct ShiftLeft_ : euml_action<ShiftLeft_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)<<T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)<<T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)<<T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)<<T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct ShiftRight_ : euml_action<ShiftRight_<T1,T2> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)>>T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)>>T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)>>T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)>>T2()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct Assign_ : euml_action<Assign_<T1,T2> >
 {
     using euml_action< Assign_<T1,T2> >::operator=;
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
- typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
- typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
- };
- typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
-
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt)=T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return (T1()(evt,fsm,state)=T2()(evt,fsm,state));
- }
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
+ typedef typename get_result_type2<T1,Event,FSM,STATE>::type type;
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
+ typedef typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type type;
+ };
+ typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt)=T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return (T1()(evt,fsm,state)=T2()(evt,fsm,state));
+ }
 };
 template <class T1>
 struct Unary_Plus_ : euml_action<Unary_Plus_<T1> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return +T1()(evt,fsm,src,tgt);
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return +T1()(evt,fsm,state);
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return +T1()(evt,fsm,src,tgt);
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return +T1()(evt,fsm,state);
+ }
 };
 template <class T1>
 struct Unary_Minus_ : euml_action<Unary_Minus_<T1> >
 {
- template <class Event,class FSM,class STATE >
- struct state_action_result
- {
+ template <class Event,class FSM,class STATE >
+ struct state_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
- };
- template <class EVT,class FSM,class SourceState,class TargetState>
- struct transition_action_result
- {
+ };
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ struct transition_action_result
+ {
         typedef typename ::boost::remove_reference<
             typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
- };
+ };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return -(T1()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
- return -(T1()(evt,fsm,state));
- }
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return -(T1()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
+ return -(T1()(evt,fsm,state));
+ }
 };
 template <class T1,class T2>
 struct Less_ : euml_action<Less_<T1,T2> >
@@ -1413,12 +1413,12 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt) < T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt) < T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)const
     {
         return (T1()(evt,fsm,state) < T2()(evt,fsm,state));
@@ -1439,12 +1439,12 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt) <= T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt) <= T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)const
     {
         return (T1()(evt,fsm,state) <= T2()(evt,fsm,state));
@@ -1465,12 +1465,12 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt) > T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt) > T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)const
     {
         return (T1()(evt,fsm,state) > T2()(evt,fsm,state));
@@ -1491,12 +1491,12 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt) >= T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt) >= T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)const
     {
         return (T1()(evt,fsm,state) >= T2()(evt,fsm,state));
@@ -1517,12 +1517,12 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt) == T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt) == T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)const
     {
         return (T1()(evt,fsm,state) == T2()(evt,fsm,state));
@@ -1543,12 +1543,12 @@
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
- template <class EVT,class FSM,class SourceState,class TargetState>
- bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return (T1()(evt,fsm,src,tgt) != T2()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
+ template <class EVT,class FSM,class SourceState,class TargetState>
+ bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return (T1()(evt,fsm,src,tgt) != T2()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
     bool operator()(Event const& evt,FSM& fsm,STATE& state)const
     {
         return (T1()(evt,fsm,state) != T2()(evt,fsm,state));

Copied: branches/release/boost/msm/front/euml/state_grammar.hpp (from r62128, /trunk/boost/msm/front/euml/state_grammar.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/state_grammar.hpp (original)
+++ branches/release/boost/msm/front/euml/state_grammar.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -39,7 +39,7 @@
 template<class StateNameTag,
          class EntryFunctor=NoAction,
          class ExitFunctor=NoAction,
- class Attributes= ::boost::fusion::vector<>,
+ class Attributes= ::boost::fusion::vector<>,
          class Flags = ::boost::mpl::vector0<>,
          class Defer = ::boost::mpl::vector0<>,
          class BASE = ::boost::msm::front::default_base_state>
@@ -56,16 +56,16 @@
     // deferred events
     typedef Defer deferred_events;
 
- template <class Event,class FSM>
- void on_entry(Event const& evt,FSM& fsm)
- {
- EntryFunctor()(evt,fsm,*this);
- }
- template <class Event,class FSM>
- void on_exit(Event const& evt,FSM& fsm)
- {
- ExitFunctor()(evt,fsm,*this);
- }
+ template <class Event,class FSM>
+ void on_entry(Event const& evt,FSM& fsm)
+ {
+ EntryFunctor()(evt,fsm,*this);
+ }
+ template <class Event,class FSM>
+ void on_exit(Event const& evt,FSM& fsm)
+ {
+ ExitFunctor()(evt,fsm,*this);
+ }
 };
 
 // provides the typedefs and interface. Concrete states derive from it.
@@ -73,7 +73,7 @@
          int ZoneIndex=-1,
          class EntryFunctor=NoAction,
          class ExitFunctor=NoAction,
- class Attributes= ::boost::fusion::vector<>,
+ class Attributes= ::boost::fusion::vector<>,
          class Flags = ::boost::mpl::vector0<>,
          class Defer = ::boost::mpl::vector0<>,
          class BASE = default_base_state>
@@ -95,23 +95,23 @@
     // deferred events
     typedef Defer deferred_events;
 
- template <class Event,class FSM>
- void on_entry(Event const& evt,FSM& fsm)
- {
- EntryFunctor()(evt,fsm,*this);
- }
- template <class Event,class FSM>
- void on_exit(Event const& evt,FSM& fsm)
- {
- ExitFunctor()(evt,fsm,*this);
- }
+ template <class Event,class FSM>
+ void on_entry(Event const& evt,FSM& fsm)
+ {
+ EntryFunctor()(evt,fsm,*this);
+ }
+ template <class Event,class FSM>
+ void on_exit(Event const& evt,FSM& fsm)
+ {
+ ExitFunctor()(evt,fsm,*this);
+ }
 };
 // provides the typedefs and interface. Concrete states derive from it.
 template<class StateNameTag,
          int ZoneIndex=-1,
          class EntryFunctor=NoAction,
          class ExitFunctor=NoAction,
- class Attributes= ::boost::fusion::vector<>,
+ class Attributes= ::boost::fusion::vector<>,
          class Flags = ::boost::mpl::vector0<>,
          class Defer = ::boost::mpl::vector0<>,
          class BASE = default_base_state>
@@ -130,16 +130,16 @@
     // deferred events
     typedef Defer deferred_events;
 
- template <class Event,class FSM>
- void on_entry(Event const& evt,FSM& fsm)
- {
- EntryFunctor()(evt,fsm,*this);
- }
- template <class Event,class FSM>
- void on_exit(Event const& evt,FSM& fsm)
- {
- ExitFunctor()(evt,fsm,*this);
- }
+ template <class Event,class FSM>
+ void on_entry(Event const& evt,FSM& fsm)
+ {
+ EntryFunctor()(evt,fsm,*this);
+ }
+ template <class Event,class FSM>
+ void on_exit(Event const& evt,FSM& fsm)
+ {
+ ExitFunctor()(evt,fsm,*this);
+ }
 };
 
 // provides the typedefs and interface. Concrete states derive from it.
@@ -147,7 +147,7 @@
          class Event,
          class EntryFunctor=NoAction,
          class ExitFunctor=NoAction,
- class Attributes= ::boost::fusion::vector<>,
+ class Attributes= ::boost::fusion::vector<>,
          class Flags = ::boost::mpl::vector0<>,
          class Defer = ::boost::mpl::vector0<>,
          class BASE = default_base_state>
@@ -169,16 +169,16 @@
     // deferred events
     typedef Defer deferred_events;
 
- template <class Evt,class FSM>
- void on_entry(Evt const& evt,FSM& fsm)
- {
- EntryFunctor()(evt,fsm,*this);
- }
- template <class Evt,class FSM>
- void on_exit(Evt const& evt,FSM& fsm)
- {
- ExitFunctor()(evt,fsm,*this);
- }
+ template <class Evt,class FSM>
+ void on_entry(Evt const& evt,FSM& fsm)
+ {
+ EntryFunctor()(evt,fsm,*this);
+ }
+ template <class Evt,class FSM>
+ void on_exit(Evt const& evt,FSM& fsm)
+ {
+ ExitFunctor()(evt,fsm,*this);
+ }
 };
 
 struct BuildActions;
@@ -194,273 +194,273 @@
                     proto::comma<BuildActions,BuildActions >,
                     ActionSequence_<boost::mpl::push_back<
                         make_vector_one_row<BuildActions(proto::_left)>(),
- BuildActions(proto::_right)>()>()
- >,
+ BuildActions(proto::_right)>()>()
+ >,
         proto::when <
                     proto::comma<BuildActionSequence,BuildActions >,
                     ActionSequence_<boost::mpl::push_back<
                         get_sequence<BuildActionSequence(proto::_left) >(),
- BuildActions(proto::_right) >() >()
- >
+ BuildActions(proto::_right) >() >()
+ >
>
 {};
 
 struct BuildActionsCases
 {
- // The primary template matches nothing:
- template<typename Tag>
- struct case_
- : proto::not_<proto::_>
- {};
+ // The primary template matches nothing:
+ template<typename Tag>
+ struct case_
+ : proto::not_<proto::_>
+ {};
 };
 
 template<>
 struct BuildActionsCases::case_<proto::tag::pre_inc>
- : proto::when<
+ : proto::when<
             proto::pre_inc<BuildActions >,
             Pre_inc_< BuildActions(proto::_child)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::pre_dec>
- : proto::when<
+ : proto::when<
             proto::pre_dec<BuildActions >,
             Pre_dec_< BuildActions(proto::_child)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::post_inc>
- : proto::when<
+ : proto::when<
             proto::post_inc<BuildActions >,
             Post_inc_< BuildActions(proto::_child)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::post_dec>
- : proto::when<
+ : proto::when<
             proto::post_dec<BuildActions >,
             Post_dec_< BuildActions(proto::_child)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::dereference>
- : proto::when<
+ : proto::when<
             proto::dereference<BuildActions >,
             Deref_< BuildActions(proto::_child)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::plus>
- : proto::when<
+ : proto::when<
             proto::plus<BuildActions,BuildActions >,
             Plus_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::minus>
- : proto::when<
+ : proto::when<
             proto::minus<BuildActions,BuildActions >,
             Minus_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::multiplies>
- : proto::when<
+ : proto::when<
             proto::multiplies<BuildActions,BuildActions >,
             Multiplies_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::divides>
- : proto::when<
+ : proto::when<
             proto::divides<BuildActions,BuildActions >,
             Divides_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::modulus>
- : proto::when<
+ : proto::when<
             proto::modulus<BuildActions,BuildActions >,
             Modulus_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::bitwise_and>
- : proto::when<
+ : proto::when<
             proto::bitwise_and<BuildActions,BuildActions >,
             Bitwise_And_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::bitwise_or>
- : proto::when<
+ : proto::when<
             proto::bitwise_or<BuildActions,BuildActions >,
             Bitwise_Or_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::bitwise_xor>
- : proto::when<
+ : proto::when<
             proto::bitwise_xor<BuildActions,BuildActions >,
             Bitwise_Xor_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 
 template<>
 struct BuildActionsCases::case_<proto::tag::plus_assign>
- : proto::when<
+ : proto::when<
             proto::plus_assign<BuildActions,BuildActions >,
             Plus_Assign_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::minus_assign>
- : proto::when<
+ : proto::when<
             proto::minus_assign<BuildActions,BuildActions >,
             Minus_Assign_<BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::multiplies_assign>
- : proto::when<
+ : proto::when<
             proto::multiplies_assign<BuildActions,BuildActions >,
             Multiplies_Assign_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::divides_assign>
- : proto::when<
+ : proto::when<
             proto::divides_assign<BuildActions,BuildActions >,
             Divides_Assign_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::modulus_assign>
- : proto::when<
+ : proto::when<
             proto::modulus_assign<BuildActions,BuildActions >,
             Modulus_Assign_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::shift_left_assign>
- : proto::when<
+ : proto::when<
             proto::shift_left_assign<BuildActions,BuildActions >,
             ShiftLeft_Assign_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::shift_right_assign>
- : proto::when<
+ : proto::when<
             proto::shift_right_assign<BuildActions,BuildActions >,
             ShiftRight_Assign_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::shift_left>
- : proto::when<
+ : proto::when<
             proto::shift_left<BuildActions,BuildActions >,
             ShiftLeft_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::shift_right>
- : proto::when<
+ : proto::when<
             proto::shift_right<BuildActions,BuildActions >,
             ShiftRight_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::assign>
- : proto::when<
+ : proto::when<
             proto::assign<BuildActions,BuildActions >,
             Assign_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::subscript>
- : proto::when<
+ : proto::when<
             proto::subscript<BuildActions,BuildActions >,
             Subscript_< BuildActions(proto::_left),BuildActions(proto::_right)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::unary_plus>
- : proto::when<
+ : proto::when<
             proto::unary_plus<BuildActions >,
             Unary_Plus_< BuildActions(proto::_child)>()
- >
+ >
 {};
 template<>
 struct BuildActionsCases::case_<proto::tag::negate>
- : proto::when<
+ : proto::when<
             proto::negate<BuildActions >,
             Unary_Minus_< BuildActions(proto::_child)>()
- >
+ >
 {};
 
 template<>
 struct BuildActionsCases::case_<proto::tag::function>
     : proto::or_<
             proto::when<
- proto::function<proto::terminal<if_tag>,BuildGuards,BuildActionSequence,BuildActionSequence >,
+ proto::function<proto::terminal<if_tag>,BuildGuards,BuildActionSequence,BuildActionSequence >,
                 If_Else_<BuildGuards(proto::_child_c<1>),
- BuildActionSequence(proto::_child_c<2>),
- BuildActionSequence(proto::_child_c<3>) >()
- >,
+ BuildActionSequence(proto::_child_c<2>),
+ BuildActionSequence(proto::_child_c<3>) >()
+ >,
             proto::when<
- proto::function<proto::terminal<if_then_tag>,BuildGuards,BuildActionSequence >,
+ proto::function<proto::terminal<if_then_tag>,BuildGuards,BuildActionSequence >,
                 If_Then_<BuildGuards(proto::_child_c<1>),
- BuildActionSequence(proto::_child_c<2>)>()
- >,
- proto::when<
- proto::function<proto::terminal<while_do_tag>,BuildGuards,BuildActionSequence >,
+ BuildActionSequence(proto::_child_c<2>)>()
+ >,
+ proto::when<
+ proto::function<proto::terminal<while_do_tag>,BuildGuards,BuildActionSequence >,
                     While_Do_<BuildGuards(proto::_child_c<1>),
- BuildActionSequence(proto::_child_c<2>) >()
- >,
- proto::when<
- proto::function<proto::terminal<do_while_tag>,BuildGuards,BuildActionSequence >,
+ BuildActionSequence(proto::_child_c<2>) >()
+ >,
+ proto::when<
+ proto::function<proto::terminal<do_while_tag>,BuildGuards,BuildActionSequence >,
                     Do_While_<BuildGuards(proto::_child_c<1>),
- BuildActionSequence(proto::_child_c<2>) >()
- >,
+ BuildActionSequence(proto::_child_c<2>) >()
+ >,
             proto::when<
- proto::function<proto::terminal<for_loop_tag>,
+ proto::function<proto::terminal<for_loop_tag>,
                                 BuildActionSequence,BuildGuards,BuildActionSequence,BuildActionSequence>,
                 For_Loop_<BuildActionSequence(proto::_child_c<1>),
- BuildGuards(proto::_child_c<2>),
- BuildActionSequence(proto::_child_c<3>),
+ BuildGuards(proto::_child_c<2>),
+ BuildActionSequence(proto::_child_c<3>),
                          BuildActionSequence(proto::_child_c<4>) >()
- >,
+ >,
          proto::or_<
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions >,
                     get_fct<proto::_child_c<0>,BuildActions(proto::_child_c<1>) >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_> >,
                     get_fct<proto::_child_c<0> >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions >,
                     get_fct<proto::_child_c<0>,BuildActions(proto::_child_c<1>),BuildActions(proto::_child_c<2>) >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions,BuildActions >,
                     get_fct<proto::_child_c<0>,BuildActions(proto::_child_c<1>)
                                               ,BuildActions(proto::_child_c<2>),BuildActions(proto::_child_c<3>) >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions,BuildActions,BuildActions >,
                     get_fct<proto::_child_c<0>
                             ,BuildActions(proto::_child_c<1>),BuildActions(proto::_child_c<2>)
                             ,BuildActions(proto::_child_c<3>),BuildActions(proto::_child_c<4>) >()
- >,
+ >,
             proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions,BuildActions,BuildActions,BuildActions >,
                     get_fct<proto::_child_c<0>
                             ,BuildActions(proto::_child_c<1>),BuildActions(proto::_child_c<2>)
                             ,BuildActions(proto::_child_c<3>),BuildActions(proto::_child_c<4>)
                             ,BuildActions(proto::_child_c<5>) >()
- >
+ >
 #ifdef BOOST_MSVC
             ,proto::when<
                     proto::function<proto::terminal<proto::_>,BuildActions,BuildActions,BuildActions,BuildActions,BuildActions,BuildActions >,
@@ -468,7 +468,7 @@
                             ,BuildActions(proto::_child_c<1>),BuildActions(proto::_child_c<2>)
                             ,BuildActions(proto::_child_c<3>),BuildActions(proto::_child_c<4>)
                             ,BuildActions(proto::_child_c<5>),BuildActions(proto::_child_c<6>) >()
- >
+ >
 #endif
>
>
@@ -496,11 +496,11 @@
         proto::when<
                 proto::terminal<proto::_>,
                 get_fct<proto::_ >()
- >
+ >
>
 {};
 struct BuildActions
- : proto::switch_<BuildActionsCases>
+ : proto::switch_<BuildActionsCases>
 {};
 
 // attributes building
@@ -677,8 +677,8 @@
>
 build_state(Expr1 const& ,Expr2 const& , Attr const&, Configure const&, BASE )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
@@ -703,12 +703,12 @@
>
 build_state(Expr1 const& ,Expr2 const& ,Attr const&, Configure const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
- return func_state<StateNameTag,entry_action,exit_action,attributes_type,flags_type,deferred_type>();
+ return func_state<StateNameTag,entry_action,exit_action,attributes_type,flags_type,deferred_type>();
 }
 
 template <class StateNameTag,class Expr1,class Expr2,class Attr>
@@ -727,10 +727,10 @@
>
 build_state(Expr1 const& ,Expr2 const& ,Attr const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
- return func_state<StateNameTag,entry_action,exit_action,attributes_type>();
+ return func_state<StateNameTag,entry_action,exit_action,attributes_type>();
 }
 
 template <class StateNameTag,class Expr1,class Expr2>
@@ -748,9 +748,9 @@
>
 build_state(Expr1 const& ,Expr2 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
- return func_state<StateNameTag,entry_action,exit_action>();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ return func_state<StateNameTag,entry_action,exit_action>();
 }
 
 template <class StateNameTag,class Expr1>
@@ -765,8 +765,8 @@
>
 build_state(Expr1 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- return func_state<StateNameTag,entry_action,NoAction>();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ return func_state<StateNameTag,entry_action,NoAction>();
 }
 template<class StateNameTag>
 inline
@@ -777,7 +777,7 @@
>
 build_state()
 {
- return func_state<StateNameTag,NoAction,NoAction>();
+ return func_state<StateNameTag,NoAction,NoAction>();
 }
 
 // provides the typedefs and interface. Concrete states derive from it.
@@ -810,7 +810,7 @@
     // deferred events
     typedef Defer deferred_events;
     // customization (message queue, exceptions)
- typedef Configuration configuration;
+ typedef Configuration configuration;
 
 
     typedef BASE BaseAllStates;
@@ -1065,8 +1065,8 @@
 build_sm(STT ,Init , Expr1 const& ,Expr2 const& ,Attr const& , Configure const&, Expr3 const&, Expr4 const& , BASE )
 {
     typedef typename boost::result_of<BuildInit(Init)>::type init_type;
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
     typedef typename boost::result_of<BuildConfigure(Configure)>::type config_type;
@@ -1105,8 +1105,8 @@
>
 build_terminate_state(Expr1 const& ,Expr2 const& , Attr const&, Configure const&, BASE )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename ::boost::mpl::push_back<
         typename boost::result_of<BuildFlags(Configure)>::type,
         ::boost::msm::TerminateFlag >::type flags_type;
@@ -1134,8 +1134,8 @@
>
 build_terminate_state(Expr1 const& ,Expr2 const& ,Attr const&, Configure const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename ::boost::mpl::push_back<
         typename boost::result_of<BuildFlags(Configure)>::type,
         ::boost::msm::TerminateFlag >::type flags_type;
@@ -1162,10 +1162,10 @@
>
 build_terminate_state(Expr1 const& ,Expr2 const& ,Attr const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
- return func_state<StateNameTag,entry_action,exit_action,attributes_type, ::boost::mpl::vector< ::boost::msm::TerminateFlag> >();
+ return func_state<StateNameTag,entry_action,exit_action,attributes_type, ::boost::mpl::vector< ::boost::msm::TerminateFlag> >();
 }
 
 template <class StateNameTag,class Expr1,class Expr2>
@@ -1185,9 +1185,9 @@
>
 build_terminate_state(Expr1 const& ,Expr2 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
- return func_state<StateNameTag,entry_action,exit_action,
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ return func_state<StateNameTag,entry_action,exit_action,
                       ::boost::fusion::vector<>, ::boost::mpl::vector< ::boost::msm::TerminateFlag> >();
 }
 
@@ -1205,8 +1205,8 @@
>
 build_terminate_state(Expr1 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- return func_state<StateNameTag,entry_action,NoAction,::boost::fusion::vector<>,::boost::mpl::vector<boost::msm::TerminateFlag> >();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ return func_state<StateNameTag,entry_action,NoAction,::boost::fusion::vector<>,::boost::mpl::vector<boost::msm::TerminateFlag> >();
 }
 template<class StateNameTag>
 inline
@@ -1245,8 +1245,8 @@
>
 build_interrupt_state(EndInterruptEvent const&,Expr1 const& ,Expr2 const& , Attr const&, Configure const&, BASE )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
     typedef typename ::boost::mpl::push_back<
                 typename ::boost::mpl::push_back<
@@ -1280,8 +1280,8 @@
>
 build_interrupt_state(EndInterruptEvent const&,Expr1 const& ,Expr2 const& ,Attr const&, Configure const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
 
     typedef typename ::boost::mpl::push_back<
@@ -1292,7 +1292,7 @@
>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
 
- return func_state<StateNameTag,entry_action,exit_action,attributes_type,flags_type,deferred_type>();
+ return func_state<StateNameTag,entry_action,exit_action,attributes_type,flags_type,deferred_type>();
 }
 
 template <class StateNameTag,class Expr1,class Expr2,class Attr,class EndInterruptEvent>
@@ -1312,10 +1312,10 @@
>
 build_interrupt_state(EndInterruptEvent const&,Expr1 const& ,Expr2 const& ,Attr const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
- return func_state<StateNameTag,entry_action,exit_action,attributes_type,
+ return func_state<StateNameTag,entry_action,exit_action,attributes_type,
                      ::boost::mpl::vector< boost::msm::InterruptedFlag, boost::msm::EndInterruptFlag<EndInterruptEvent> > >();
 }
 
@@ -1336,9 +1336,9 @@
>
 build_interrupt_state(EndInterruptEvent const&,Expr1 const& ,Expr2 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
- return func_state<StateNameTag,entry_action,exit_action,
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ return func_state<StateNameTag,entry_action,exit_action,
                       ::boost::fusion::vector<>,
                       ::boost::mpl::vector< boost::msm::InterruptedFlag, boost::msm::EndInterruptFlag<EndInterruptEvent> > >();
 }
@@ -1357,8 +1357,8 @@
>
 build_interrupt_state(EndInterruptEvent const&, Expr1 const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- return func_state<StateNameTag,entry_action,NoAction, ::boost::fusion::vector<>,
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ return func_state<StateNameTag,entry_action,NoAction, ::boost::fusion::vector<>,
                      ::boost::mpl::vector<boost::msm::InterruptedFlag, boost::msm::EndInterruptFlag<EndInterruptEvent> > >();
 }
 
@@ -1397,8 +1397,8 @@
>
 build_entry_state(Expr1 const& ,Expr2 const& , Attr const&, Configure const&, BASE )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
@@ -1424,8 +1424,8 @@
>
 build_entry_state(Expr1 const& ,Expr2 const& ,Attr const&, Configure const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
@@ -1449,10 +1449,10 @@
>
 build_entry_state(Expr1 const& ,Expr2 const& ,Attr const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
- return entry_func_state<StateNameTag,ZoneIndex,entry_action,exit_action,attributes_type>();
+ return entry_func_state<StateNameTag,ZoneIndex,entry_action,exit_action,attributes_type>();
 }
 
 template <class StateNameTag,int ZoneIndex,class Expr1,class Expr2>
@@ -1471,9 +1471,9 @@
>
 build_entry_state(Expr1 const& ,Expr2 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
- return entry_func_state<StateNameTag,ZoneIndex,entry_action,exit_action>();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ return entry_func_state<StateNameTag,ZoneIndex,entry_action,exit_action>();
 }
 
 template <class StateNameTag,int ZoneIndex,class Expr1>
@@ -1489,8 +1489,8 @@
>
 build_entry_state(Expr1 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- return entry_func_state<StateNameTag,ZoneIndex,entry_action,NoAction>();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ return entry_func_state<StateNameTag,ZoneIndex,entry_action,NoAction>();
 }
 
 template <class StateNameTag,int ZoneIndex>
@@ -1503,7 +1503,7 @@
>
 build_entry_state()
 {
- return entry_func_state<StateNameTag,ZoneIndex,NoAction,NoAction>();
+ return entry_func_state<StateNameTag,ZoneIndex,NoAction,NoAction>();
 }
 
 template <class StateNameTag,class Event,class Expr1,class Expr2,class Attr,class Configure,class BASE>
@@ -1526,8 +1526,8 @@
>
 build_exit_state(Event const&,Expr1 const& ,Expr2 const& , Attr const&, Configure const&, BASE )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
@@ -1553,8 +1553,8 @@
>
 build_exit_state(Event const&,Expr1 const& ,Expr2 const& ,Attr const&, Configure const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
@@ -1578,10 +1578,10 @@
>
 build_exit_state(Event const&,Expr1 const& ,Expr2 const& ,Attr const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
- return exit_func_state<StateNameTag,Event,entry_action,exit_action,attributes_type>();
+ return exit_func_state<StateNameTag,Event,entry_action,exit_action,attributes_type>();
 }
 
 template <class StateNameTag,class Event,class Expr1,class Expr2>
@@ -1600,9 +1600,9 @@
>
 build_exit_state(Event const&,Expr1 const& ,Expr2 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
- return exit_func_state<StateNameTag,Event,entry_action,exit_action>();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ return exit_func_state<StateNameTag,Event,entry_action,exit_action>();
 }
 
 template <class StateNameTag,class Event,class Expr1>
@@ -1618,8 +1618,8 @@
>
 build_exit_state(Event const&, Expr1 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- return exit_func_state<StateNameTag,Event,entry_action,NoAction>();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ return exit_func_state<StateNameTag,Event,entry_action,NoAction>();
 }
 
 template <class StateNameTag,class Event>
@@ -1632,7 +1632,7 @@
>
 build_exit_state(Event const&)
 {
- return exit_func_state<StateNameTag,Event,NoAction,NoAction>();
+ return exit_func_state<StateNameTag,Event,NoAction,NoAction>();
 }
 
 template <class StateNameTag,int ZoneIndex,class Expr1,class Expr2,class Attr,class Configure,class BASE>
@@ -1655,8 +1655,8 @@
>
 build_explicit_entry_state(Expr1 const& ,Expr2 const& , Attr const&, Configure const&, BASE )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
@@ -1682,8 +1682,8 @@
>
 build_explicit_entry_state(Expr1 const& ,Expr2 const& ,Attr const&, Configure const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildFlags(Configure)>::type flags_type;
     typedef typename boost::result_of<BuildDeferred(Configure)>::type deferred_type;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
@@ -1707,10 +1707,10 @@
>
 build_explicit_entry_state(Expr1 const& ,Expr2 const& ,Attr const&)
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
     typedef typename boost::result_of<BuildAttributes(Attr)>::type attributes_type;
- return explicit_entry_func_state<StateNameTag,ZoneIndex,entry_action,exit_action,attributes_type>();
+ return explicit_entry_func_state<StateNameTag,ZoneIndex,entry_action,exit_action,attributes_type>();
 }
 
 template <class StateNameTag,int ZoneIndex,class Expr1,class Expr2>
@@ -1729,9 +1729,9 @@
>
 build_explicit_entry_state(Expr1 const& ,Expr2 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
- return explicit_entry_func_state<StateNameTag,ZoneIndex,entry_action,exit_action>();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ typedef typename boost::result_of<BuildActionSequence(Expr2)>::type exit_action;
+ return explicit_entry_func_state<StateNameTag,ZoneIndex,entry_action,exit_action>();
 }
 
 template <class StateNameTag,int ZoneIndex,class Expr1>
@@ -1747,8 +1747,8 @@
>
 build_explicit_entry_state(Expr1 const& )
 {
- typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
- return explicit_entry_func_state<StateNameTag,ZoneIndex,entry_action,NoAction>();
+ typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
+ return explicit_entry_func_state<StateNameTag,ZoneIndex,entry_action,NoAction>();
 }
 
 template <class StateNameTag,int ZoneIndex>
@@ -1761,7 +1761,7 @@
>
 build_explicit_entry_state()
 {
- return explicit_entry_func_state<StateNameTag,ZoneIndex,NoAction,NoAction>();
+ return explicit_entry_func_state<StateNameTag,ZoneIndex,NoAction,NoAction>();
 }
 
 

Copied: branches/release/boost/msm/front/euml/stl.hpp (from r62128, /trunk/boost/msm/front/euml/stl.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/stl.hpp (original)
+++ branches/release/boost/msm/front/euml/stl.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -14,4 +14,4 @@
 #include <boost/msm/front/euml/container.hpp>
 #include <boost/msm/front/euml/algorithm.hpp>
 
-#endif //BOOST_MSM_FRONT_EUML_STL_H
\ No newline at end of file
+#endif //BOOST_MSM_FRONT_EUML_STL_H

Copied: branches/release/boost/msm/front/euml/stt_grammar.hpp (from r62128, /trunk/boost/msm/front/euml/stt_grammar.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/stt_grammar.hpp (original)
+++ branches/release/boost/msm/front/euml/stt_grammar.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -75,8 +75,8 @@
                     proto::comma<BuildNextStates,BuildEntry >,
                     ::boost::mpl::push_back<
                                 BuildNextStates(proto::_left),
- BuildEntry(proto::_right) >()
- >
+ BuildEntry(proto::_right) >()
+ >
>
 {};
 
@@ -141,7 +141,7 @@
        , proto::when<
                 proto::divides<proto::terminal<event_tag>,BuildActionSequence >,
                 TempRow<none,proto::_left,none,
- BuildActionSequence(proto::_right) >() >
+ BuildActionSequence(proto::_right) >() >
         // event [ guard ]
        , proto::when<
                 proto::subscript<proto::terminal<event_tag>,BuildGuards >,
@@ -166,7 +166,7 @@
        , proto::when<
                 proto::divides<BuildSourceState,BuildActionSequence >,
                 TempRow<BuildSourceState(proto::_left),none,none,
- BuildActionSequence(proto::_right) >() >
+ BuildActionSequence(proto::_right) >() >
         // == source [ guard ]
        , proto::when<
                 proto::subscript<BuildSourceState,BuildGuards >,

Copied: branches/release/boost/msm/front/euml/transformation.hpp (from r62128, /trunk/boost/msm/front/euml/transformation.hpp)
==============================================================================
--- /trunk/boost/msm/front/euml/transformation.hpp (original)
+++ branches/release/boost/msm/front/euml/transformation.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -87,23 +87,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return std::back_inserter(T()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return std::back_inserter(T()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
         return std::back_inserter(T()(evt,fsm,state));
- }
+ }
 };
 
 struct back_inserter_tag {};
@@ -141,23 +141,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return std::front_inserter(T()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return std::front_inserter(T()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
         return std::front_inserter(T()(evt,fsm,state));
- }
+ }
 };
 
 struct front_inserter_tag {};
@@ -195,23 +195,23 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
- operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
- {
- return std::inserter(T()(evt,fsm,src,tgt),Pos()(evt,fsm,src,tgt));
- }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename T::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
- operator()(Event const& evt,FSM& fsm,STATE& state )const
- {
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
+ {
+ return std::inserter(T()(evt,fsm,src,tgt),Pos()(evt,fsm,src,tgt));
+ }
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename T::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
+ operator()(Event const& evt,FSM& fsm,STATE& state )const
+ {
         return std::inserter(T()(evt,fsm,state),Pos()(evt,fsm,state));
- }
+ }
 };
 
 struct inserter_tag {};
@@ -252,20 +252,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Param1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Param1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return std::transform(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt),
                               Param4()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Param1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Param1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return std::transform(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state),
@@ -291,20 +291,20 @@
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
     template <class EVT,class FSM,class SourceState,class TargetState>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Param1::tag_type,action_tag>::type,
- typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Param1::tag_type,action_tag>::type,
+ typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
         return std::transform (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt),
                                Param4()(evt,fsm,src,tgt),Param5()(evt,fsm,src,tgt));
     }
- template <class Event,class FSM,class STATE>
- typename ::boost::enable_if<
- typename ::boost::mpl::has_key<
- typename Param1::tag_type,state_action_tag>::type,
- typename state_action_result<Event,FSM,STATE>::type >::type
+ template <class Event,class FSM,class STATE>
+ typename ::boost::enable_if<
+ typename ::boost::mpl::has_key<
+ typename Param1::tag_type,state_action_tag>::type,
+ typename state_action_result<Event,FSM,STATE>::type >::type
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
         return std::transform (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state),

Copied: branches/release/boost/msm/front/functor_row.hpp (from r62128, /trunk/boost/msm/front/functor_row.hpp)
==============================================================================
--- /trunk/boost/msm/front/functor_row.hpp (original)
+++ branches/release/boost/msm/front/functor_row.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -165,7 +165,7 @@
     template<class TGT>
     struct get_row_target
     {
- typedef typename TGT::Target type;
+ typedef typename TGT::Target type;
     };
 
     template <class EVENT,class ACTION=none,class GUARD=none>
@@ -257,9 +257,9 @@
             FCT()(evt_,fsm_,state_);
         }
         private:
- EVT const& evt_;
- FSM& fsm_;
- STATE& state_;
+ EVT const& evt_;
+ FSM& fsm_;
+ STATE& state_;
         };
         template <class EVT,class FSM,class SourceState,class TargetState>
         struct transition_action_result

Copied: branches/release/boost/msm/front/internal_row.hpp (from r62128, /trunk/boost/msm/front/internal_row.hpp)
==============================================================================
--- /trunk/boost/msm/front/internal_row.hpp (original)
+++ branches/release/boost/msm/front/internal_row.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -19,15 +19,15 @@
 
 namespace boost { namespace msm { namespace front
 {
- template<
- class Event
+ template<
+ class Event
         , typename CalledForAction
         , void (CalledForAction::*action)(Event const&)
- >
- struct a_internal
- {
+ >
+ struct a_internal
+ {
         typedef sm_a_i_row_tag row_type_tag;
- typedef Event Evt;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                 AllStates& all_states)
@@ -37,19 +37,19 @@
                 (fsm,evt,src,tgt,all_states,
                 ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
         }
- };
+ };
 
- template<
+ template<
         class Event
         , typename CalledForAction
         , void (CalledForAction::*action)(Event const&)
         , typename CalledForGuard
         , bool (CalledForGuard::*guard)(Event const&)
- >
- struct internal
- {
+ >
+ struct internal
+ {
         typedef sm_i_row_tag row_type_tag;
- typedef Event Evt;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                 AllStates& all_states)
@@ -68,16 +68,16 @@
                 (fsm,evt,src,tgt,all_states,
                 ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
         }
- };
- template<
- class Event
+ };
+ template<
+ class Event
         , typename CalledForGuard
         , bool (CalledForGuard::*guard)(Event const&)
- >
- struct g_internal
- {
+ >
+ struct g_internal
+ {
         typedef sm_g_i_row_tag row_type_tag;
- typedef Event Evt;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static bool guard_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                AllStates& all_states)
@@ -88,13 +88,13 @@
                 ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
         }
     };
- template<
- class Event
- >
- struct _internal
- {
+ template<
+ class Event
+ >
+ struct _internal
+ {
         typedef sm__i_row_tag row_type_tag;
- typedef Event Evt;
+ typedef Event Evt;
     };
 }}}
 

Copied: branches/release/boost/msm/front/row2.hpp (from r62128, /trunk/boost/msm/front/row2.hpp)
==============================================================================
--- /trunk/boost/msm/front/row2.hpp (original)
+++ branches/release/boost/msm/front/row2.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -19,32 +19,32 @@
 
 namespace boost { namespace msm { namespace front
 {
- template<
- typename T1
- , class Event
- , typename T2
- >
- struct _row2
- {
+ template<
+ typename T1
+ , class Event
+ , typename T2
+ >
+ struct _row2
+ {
         typedef _row_tag row_type_tag;
- typedef T1 Source;
- typedef T2 Target;
- typedef Event Evt;
- };
-
- template<
- typename T1
- , class Event
- , typename T2
+ typedef T1 Source;
+ typedef T2 Target;
+ typedef Event Evt;
+ };
+
+ template<
+ typename T1
+ , class Event
+ , typename T2
         , typename CalledForAction
- , void (CalledForAction::*action)(Event const&)
- >
- struct a_row2
- {
+ , void (CalledForAction::*action)(Event const&)
+ >
+ struct a_row2
+ {
         typedef a_row_tag row_type_tag;
- typedef T1 Source;
- typedef T2 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T2 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                 AllStates& all_states)
@@ -54,23 +54,23 @@
                 (fsm,evt,src,tgt,all_states,
                 ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
         }
- };
+ };
 
- template<
- typename T1
- , class Event
- , typename T2
+ template<
+ typename T1
+ , class Event
+ , typename T2
         , typename CalledForAction
         , void (CalledForAction::*action)(Event const&)
         , typename CalledForGuard
         , bool (CalledForGuard::*guard)(Event const&)
- >
- struct row2
- {
+ >
+ struct row2
+ {
         typedef row_tag row_type_tag;
- typedef T1 Source;
- typedef T2 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T2 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState, class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                 AllStates& all_states)
@@ -89,20 +89,20 @@
                 (fsm,evt,src,tgt,all_states,
                 ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
         }
- };
- template<
- typename T1
- , class Event
- , typename T2
+ };
+ template<
+ typename T1
+ , class Event
+ , typename T2
         , typename CalledForGuard
         , bool (CalledForGuard::*guard)(Event const&)
- >
- struct g_row2
- {
+ >
+ struct g_row2
+ {
         typedef g_row_tag row_type_tag;
- typedef T1 Source;
- typedef T2 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T2 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static bool guard_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                AllStates& all_states)
@@ -114,18 +114,18 @@
         }
     };
     // internal transitions
- template<
- typename T1
- , class Event
+ template<
+ typename T1
+ , class Event
         , typename CalledForAction
         , void (CalledForAction::*action)(Event const&)
- >
- struct a_irow2
- {
+ >
+ struct a_irow2
+ {
         typedef a_irow_tag row_type_tag;
- typedef T1 Source;
- typedef T1 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T1 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                 AllStates& all_states)
@@ -135,22 +135,22 @@
                 (fsm,evt,src,tgt,all_states,
                 ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
         }
- };
+ };
 
- template<
- typename T1
- , class Event
+ template<
+ typename T1
+ , class Event
         , typename CalledForAction
         , void (CalledForAction::*action)(Event const&)
         , typename CalledForGuard
         , bool (CalledForGuard::*guard)(Event const&)
- >
- struct irow2
- {
+ >
+ struct irow2
+ {
         typedef irow_tag row_type_tag;
- typedef T1 Source;
- typedef T1 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T1 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                 AllStates& all_states)
@@ -169,19 +169,19 @@
                 (fsm,evt,src,tgt,all_states,
                 ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
         }
- };
- template<
- typename T1
- , class Event
+ };
+ template<
+ typename T1
+ , class Event
         , typename CalledForGuard
         , bool (CalledForGuard::*guard)(Event const&)
- >
- struct g_irow2
- {
+ >
+ struct g_irow2
+ {
         typedef g_irow_tag row_type_tag;
- typedef T1 Source;
- typedef T1 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T1 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static bool guard_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt,
                                AllStates& all_states)

Copied: branches/release/boost/msm/front/state_machine_def.hpp (from r62128, /trunk/boost/msm/front/state_machine_def.hpp)
==============================================================================
--- /trunk/boost/msm/front/state_machine_def.hpp (original)
+++ branches/release/boost/msm/front/state_machine_def.hpp 2010-06-17 14:15:19 EDT (Thu, 17 Jun 2010)
@@ -26,61 +26,61 @@
 template<class Derived,class BaseState = default_base_state>
 struct state_machine_def : public boost::msm::front::detail::state_base<BaseState>
 {
- // tags
- // default: no flag
- typedef ::boost::mpl::vector0<> flag_list;
- //default: no deferred events
- typedef ::boost::mpl::vector0<> deferred_events;
+ // tags
+ // default: no flag
+ typedef ::boost::mpl::vector0<> flag_list;
+ //default: no deferred events
+ typedef ::boost::mpl::vector0<> deferred_events;
     // customization (message queue, exceptions)
- typedef ::boost::mpl::vector0<> configuration;
+ typedef ::boost::mpl::vector0<> configuration;
 
     typedef BaseState BaseAllStates;
- template<
- typename T1
- , class Event
- , typename T2
- , void (Derived::*action)(Event const&)
- >
- struct a_row
- {
+ template<
+ typename T1
+ , class Event
+ , typename T2
+ , void (Derived::*action)(Event const&)
+ >
+ struct a_row
+ {
         typedef a_row_tag row_type_tag;
- typedef T1 Source;
- typedef T2 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T2 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState&,TargetState&, AllStates&)
         {
             // in this front-end, we don't need to know source and target states
             (fsm.*action)(evt);
         }
- };
+ };
 
- template<
- typename T1
- , class Event
- , typename T2
- >
- struct _row
- {
+ template<
+ typename T1
+ , class Event
+ , typename T2
+ >
+ struct _row
+ {
         typedef _row_tag row_type_tag;
- typedef T1 Source;
- typedef T2 Target;
- typedef Event Evt;
- };
-
- template<
- typename T1
- , class Event
- , typename T2
- , void (Derived::*action)(Event const&)
- , bool (Derived::*guard)(Event const&)
- >
- struct row
- {
+ typedef T1 Source;
+ typedef T2 Target;
+ typedef Event Evt;
+ };
+
+ template<
+ typename T1
+ , class Event
+ , typename T2
+ , void (Derived::*action)(Event const&)
+ , bool (Derived::*guard)(Event const&)
+ >
+ struct row
+ {
         typedef row_tag row_type_tag;
- typedef T1 Source;
- typedef T2 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T2 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState, class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState&,TargetState&,AllStates&)
         {
@@ -93,19 +93,19 @@
             // in this front-end, we don't need to know source and target states
             return (fsm.*guard)(evt);
         }
- };
- template<
- typename T1
- , class Event
- , typename T2
- , bool (Derived::*guard)(Event const&)
- >
- struct g_row
- {
+ };
+ template<
+ typename T1
+ , class Event
+ , typename T2
+ , bool (Derived::*guard)(Event const&)
+ >
+ struct g_row
+ {
         typedef g_row_tag row_type_tag;
- typedef T1 Source;
- typedef T2 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T2 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static bool guard_call(FSM& fsm,Event const& evt,SourceState&,TargetState&,AllStates&)
         {
@@ -114,37 +114,37 @@
         }
     };
     // internal transitions
- template<
- typename T1
- , class Event
- , void (Derived::*action)(Event const&)
- >
- struct a_irow
- {
+ template<
+ typename T1
+ , class Event
+ , void (Derived::*action)(Event const&)
+ >
+ struct a_irow
+ {
         typedef a_irow_tag row_type_tag;
- typedef T1 Source;
- typedef T1 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T1 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState&,TargetState&,AllStates&)
         {
             // in this front-end, we don't need to know source and target states
             (fsm.*action)(evt);
         }
- };
+ };
 
- template<
- typename T1
- , class Event
- , void (Derived::*action)(Event const&)
- , bool (Derived::*guard)(Event const&)
- >
- struct irow
- {
+ template<
+ typename T1
+ , class Event
+ , void (Derived::*action)(Event const&)
+ , bool (Derived::*guard)(Event const&)
+ >
+ struct irow
+ {
         typedef irow_tag row_type_tag;
- typedef T1 Source;
- typedef T1 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T1 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static void action_call(FSM& fsm,Event const& evt,SourceState&,TargetState&,AllStates&)
         {
@@ -157,18 +157,18 @@
             // in this front-end, we don't need to know source and target states
             return (fsm.*guard)(evt);
         }
- };
- template<
- typename T1
- , class Event
- , bool (Derived::*guard)(Event const&)
- >
- struct g_irow
- {
+ };
+ template<
+ typename T1
+ , class Event
+ , bool (Derived::*guard)(Event const&)
+ >
+ struct g_irow
+ {
         typedef g_irow_tag row_type_tag;
- typedef T1 Source;
- typedef T1 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T1 Target;
+ typedef Event Evt;
         template <class FSM,class SourceState,class TargetState,class AllStates>
         static bool guard_call(FSM& fsm,Event const& evt,SourceState&,TargetState&,AllStates&)
         {
@@ -177,16 +177,16 @@
         }
     };
     // internal row withou action or guard. Does nothing except forcing the event to be ignored.
- template<
- typename T1
- , class Event
- >
- struct _irow
- {
+ template<
+ typename T1
+ , class Event
+ >
+ struct _irow
+ {
         typedef _irow_tag row_type_tag;
- typedef T1 Source;
- typedef T1 Target;
- typedef Event Evt;
+ typedef T1 Source;
+ typedef T1 Target;
+ typedef Event Evt;
     };
 protected:
     // Default no-transition handler. Can be replaced in the Derived SM class.


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