[Boost-commit] svn:boost r58461 - in sandbox/msm/boost/msm: . back front front/euml

Subject: [Boost-commit] svn:boost r58461 - in sandbox/msm/boost/msm: . back front front/euml
From: christophe.j.henry_at_[hidden]
Date: 2009-12-18 17:28:00

Author: chenry
Date: 2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
New Revision: 58461
URL: http://svn.boost.org/trac/boost/changeset/58461

Log:
after review: started implementation of review issues:
- some SFINAE replaced by tag dispatching
- dispatch speed gain
- copy speed gain
- minor eUML cleanup
Added:
   sandbox/msm/boost/msm/common.hpp   (contents, props changed)
Text files modified: 
   sandbox/msm/boost/msm/back/common_types.hpp        |     5                                         
   sandbox/msm/boost/msm/back/dispatch_table.hpp      |    46 ++--                                    
   sandbox/msm/boost/msm/back/state_machine.hpp       |   406 ++++++++++++++++++++++++++------------- 
   sandbox/msm/boost/msm/back/tools.hpp               |     6                                         
   sandbox/msm/boost/msm/front/euml/common.hpp        |     2                                         
   sandbox/msm/boost/msm/front/euml/operator.hpp      |     1                                         
   sandbox/msm/boost/msm/front/euml/state_grammar.hpp |    45 ++++                                    
   sandbox/msm/boost/msm/front/functor_row.hpp        |    10                                         
   8 files changed, 349 insertions(+), 172 deletions(-)

Modified: sandbox/msm/boost/msm/back/common_types.hpp
==============================================================================
--- sandbox/msm/boost/msm/back/common_types.hpp	(original)
+++ sandbox/msm/boost/msm/back/common_types.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -12,6 +12,7 @@
 #define BOOST_MSM_COMMON_TYPES_H
 
 #include <boost/tuple/tuple.hpp>
+#include <boost/msm/common.hpp>
 
 namespace boost { namespace msm { namespace back
 {
@@ -28,10 +29,6 @@
 
 typedef HandledEnum execute_return;
 
-// wrapper for mpl::for_each as showed in the C++ Template Metaprogramming ch. 9
-template <class T>
-struct wrap{};
-
 }}}
 
 #endif //BOOST_MSM_COMMON_TYPES_H

Modified: sandbox/msm/boost/msm/back/dispatch_table.hpp
==============================================================================
--- sandbox/msm/boost/msm/back/dispatch_table.hpp	(original)
+++ sandbox/msm/boost/msm/back/dispatch_table.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -33,7 +33,7 @@
 {
  private:
     // This is a table of these function pointers.
-    typedef std::pair<int,HandledEnum> (*cell)(Fsm&, int,Event const&);
+    typedef HandledEnum (*cell)(Fsm&, int,int,Event const&);
     typedef bool (*guard)(Fsm&, Event const&);
 
     // class used to build a chain (or sequence) of transitions for a given event and start state
@@ -49,42 +49,44 @@
         {
             template <class Sequence>
             static
-            typename ::boost::enable_if<typename ::boost::mpl::empty<Sequence>::type,std::pair<int,HandledEnum> >::type
-            execute(Fsm& , int state, Event const& ,
-                    ::boost::msm::back::dummy<0> = 0)
+            HandledEnum
+            execute(Fsm& , int, int, Event const& , ::boost::mpl::true_ const & )
             {
                 // if at least one guard rejected, this will be ignored, otherwise will generate an error
-                return std::make_pair(state,HANDLED_FALSE);
+                return HANDLED_FALSE;
             }
 
             template <class Sequence>
             static
-            typename ::boost::disable_if<typename ::boost::mpl::empty<Sequence>::type,std::pair<int,HandledEnum> >::type
-            execute(Fsm& fsm, int state, Event const& evt,
-                    ::boost::msm::back::dummy<1> = 0)
+            HandledEnum
+            execute(Fsm& fsm, int region_index , int state, Event const& evt,
+                    ::boost::mpl::false_ const & )
             {
                  // try the first guard
                  typedef typename ::boost::mpl::front<Sequence>::type first_row;
-                 std::pair<int,HandledEnum> res = first_row::execute(fsm,state,evt);
-                 if (HANDLED_TRUE!=res.second)
+                 HandledEnum res = first_row::execute(fsm,region_index,state,evt);
+                 if (HANDLED_TRUE!=res)
                  {
                      // if the first rejected, move on to the next one
-                     std::pair<int,HandledEnum> sub_res = 
-                         execute<typename ::boost::mpl::pop_front<Sequence>::type>(fsm,state,evt);
+                    HandledEnum sub_res = 
+                         execute<typename ::boost::mpl::pop_front<Sequence>::type>(fsm,region_index,state,evt,
+                            ::boost::mpl::bool_<
+                                ::boost::mpl::empty<typename ::boost::mpl::pop_front<Sequence>::type>::type::value>());
                      // if at least one guards rejects, the event will not generate a call to no_transition
-                     HandledEnum handled = ((HANDLED_GUARD_REJECT==sub_res.second) || 
-                                            (HANDLED_GUARD_REJECT==res.second))?
-                                                HANDLED_GUARD_REJECT:sub_res.second;
-                     return std::make_pair(sub_res.first,handled);
+                     HandledEnum handled = ((HANDLED_GUARD_REJECT==sub_res) || 
+                                            (HANDLED_GUARD_REJECT==res))?
+                                                HANDLED_GUARD_REJECT:sub_res;
+                     return handled;
                  }
                  return res;
             }
         };
         // Take the transition action and return the next state.
-        static std::pair<int,HandledEnum> execute(Fsm& fsm, int state, Event const& evt)
+        static HandledEnum execute(Fsm& fsm, int region_index, int state, Event const& evt)
         {
             // forward to helper
-            return execute_helper::template execute<Seq>(fsm,state,evt);
+            return execute_helper::template execute<Seq>(fsm,region_index,state,evt,
+                ::boost::mpl::bool_< ::boost::mpl::empty<Seq>::type::value>());
         }
     };
     // nullary metafunction whose only job is to prevent early evaluation of _1
@@ -138,7 +140,7 @@
             {}
         template <class State>
         typename ::boost::enable_if<typename has_state_delayed_event<State,Event>::type,void>::type
-        operator()(boost::msm::back::wrap<State> const&,boost::msm::back::dummy<0> = 0)
+        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));
@@ -147,7 +149,7 @@
             }
         template <class State>
         typename ::boost::disable_if<typename has_state_delayed_event<State,Event>::type,void >::type
-        operator()(boost::msm::back::wrap<State> const&,boost::msm::back::dummy<0> = 0)
+        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));
@@ -172,7 +174,7 @@
         // this event is an automatic one (not a real one, just one for use in event-less transitions)
         // Note this event cannot be used as deferred!
             template <class State>
-        void operator()(boost::msm::back::wrap<State> const&)
+        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));
@@ -190,7 +192,7 @@
     {
         // Initialize cells for no transition
             ::boost::mpl::for_each<typename generate_state_set<Stt>::type, 
-                               boost::msm::back::wrap< ::boost::mpl::placeholders::_1> >
+                               boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                         (default_init_cell<Event>(this,entries));
 
         // build chaining rows for rows coming from the same state and the current event

Modified: sandbox/msm/boost/msm/back/state_machine.hpp
==============================================================================
--- sandbox/msm/boost/msm/back/state_machine.hpp	(original)
+++ sandbox/msm/boost/msm/back/state_machine.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -166,6 +166,20 @@
         visitors                                                      m_state_visitors;
     };
 
+    template <class StateType,class Enable=void>
+    struct deferred_msg_queue_helper 
+    {
+    };
+    template <class StateType>
+    struct deferred_msg_queue_helper<StateType,
+        typename ::boost::enable_if< 
+            typename ::boost::msm::back::has_fsm_delayed_events<StateType>::type >::type> 
+    {
+    public:
+        deferred_msg_queue_helper():m_deferred_events_queue(){}
+        deferred_events_queue_t     m_deferred_events_queue;
+    };
+
  public: 
     // tags
     typedef int composite_tag;
@@ -302,7 +316,7 @@
             return false;
         }
         // Take the transition action and return the next state.
-        static std::pair<int,HandledEnum> execute(library_sm& fsm, int state, Event const& evt)
+        static HandledEnum execute(library_sm& fsm, int region_index, int state, Event const& evt)
         {
 
             BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value));
@@ -312,12 +326,12 @@
             if (!::boost::is_same<T1,current_state_type>::value && 
                 !is_exit_state_active<T1,get_owner<T1,library_sm> >(fsm))
             {
-                return std::make_pair(current_state,HANDLED_FALSE);
+                return HANDLED_FALSE;
             }
             if (!check_guard(fsm,evt))
             {
                 // guard rejected the event, we stay in the current one
-                return std::make_pair(current_state,HANDLED_GUARD_REJECT);
+                return HANDLED_GUARD_REJECT;
             }
 
             // the guard condition has already been checked
@@ -332,7 +346,8 @@
             // and finally the entry method of the new current state
             convert_event_and_execute_entry<next_state_type,T2>
                 (::boost::fusion::at_key<next_state_type>(fsm.m_substate_list),evt,fsm);
-            return std::make_pair(next_state,HANDLED_TRUE);
+            fsm.m_states[region_index]=next_state;
+            return HANDLED_TRUE;
         }
     };
 
@@ -376,7 +391,7 @@
             return false;
         }
         // Take the transition action and return the next state.
-        static std::pair<int,HandledEnum> execute(library_sm& fsm, int state, Event const& evt)
+        static HandledEnum execute(library_sm& fsm, int region_index, int state, Event const& evt)
         {
             BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value));
             BOOST_STATIC_CONSTANT(int, next_state = (get_state_id<stt,next_state_type>::type::value));
@@ -385,12 +400,12 @@
             if (!::boost::is_same<T1,current_state_type>::value && 
                 !is_exit_state_active<T1,get_owner<T1,library_sm> >(fsm))
             {
-                return std::make_pair(current_state,HANDLED_FALSE);
+                return HANDLED_FALSE;
             }
             if (!check_guard(fsm,evt))
             {
                 // guard rejected the event, we stay in the current one
-                return std::make_pair(current_state,HANDLED_GUARD_REJECT);
+                return HANDLED_GUARD_REJECT;
             }
             // the guard condition has already been checked
             execute_exit<current_state_type>
@@ -400,7 +415,8 @@
             convert_event_and_execute_entry<next_state_type,T2>
                 (::boost::fusion::at_key<next_state_type>(fsm.m_substate_list),evt,fsm);
 
-            return std::make_pair(next_state,HANDLED_TRUE);
+            fsm.m_states[region_index]=next_state;
+            return HANDLED_TRUE;
         }
     };
 
@@ -435,7 +451,7 @@
         >::type next_state_type;
 
         // Take the transition action and return the next state.
-        static std::pair<int,HandledEnum> execute(library_sm& fsm, int state, Event const& evt)
+        static HandledEnum execute(library_sm& fsm, int region_index, int state, Event const& evt)
         {
             BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value));
             BOOST_STATIC_CONSTANT(int, next_state = (get_state_id<stt,next_state_type>::type::value));
@@ -445,7 +461,7 @@
             if (!::boost::is_same<T1,current_state_type>::value && 
                 !is_exit_state_active<T1,get_owner<T1,library_sm> >(fsm))
             {
-                return std::make_pair(current_state,HANDLED_FALSE);
+                return HANDLED_FALSE;
             }
             // no need to check the guard condition
             // first call the exit method of the current state
@@ -461,7 +477,8 @@
             convert_event_and_execute_entry<next_state_type,T2>
                 (::boost::fusion::at_key<next_state_type>(fsm.m_substate_list),evt,fsm);
 
-            return std::make_pair(next_state,HANDLED_TRUE);
+            fsm.m_states[region_index]=next_state;
+            return HANDLED_TRUE;
         }
     };
 
@@ -496,7 +513,7 @@
         >::type next_state_type;
 
         // Take the transition action and return the next state.
-        static std::pair<int,HandledEnum> execute(library_sm& fsm, int state, Event const& evt)
+        static HandledEnum execute(library_sm& fsm, int region_index, int state, Event const& evt)
         {
             BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value));
             BOOST_STATIC_CONSTANT(int, next_state = (get_state_id<stt,next_state_type>::type::value));
@@ -506,7 +523,7 @@
             if (!::boost::is_same<T1,current_state_type>::value && 
                 !is_exit_state_active<T1,get_owner<T1,library_sm> >(fsm))
             {
-                return std::make_pair(current_state,HANDLED_FALSE);
+                return HANDLED_FALSE;
             }
             // first call the exit method of the current state
             execute_exit<current_state_type>
@@ -516,7 +533,8 @@
             convert_event_and_execute_entry<next_state_type,T2>
                 (::boost::fusion::at_key<next_state_type>(fsm.m_substate_list),evt,fsm);
 
-            return std::make_pair(next_state,HANDLED_TRUE);
+            fsm.m_states[region_index]=next_state;
+            return HANDLED_TRUE;
         }
     };
 
@@ -532,11 +550,12 @@
         typedef Evt                 Event;
 
         // Take the transition action and return the next state.
-        static std::pair<int,HandledEnum> execute(library_sm& fsm, int state, Event const& evt)
+        static HandledEnum execute(library_sm& fsm, int region_index, int , Event const& evt)
         {
              execute_return res = 
-                (::boost::fusion::at_key<current_state_type>(fsm.m_substate_list)).process_event(evt);            
-             return std::make_pair(get_state_id<stt,T1>::type::value,res);
+                (::boost::fusion::at_key<current_state_type>(fsm.m_substate_list)).process_event(evt); 
+             fsm.m_states[region_index]=get_state_id<stt,T1>::type::value;
+             return res;
         }
     };
     template <class Composite,class Event>
@@ -634,7 +653,7 @@
     {
         // call on_entry on this SM
         (static_cast<Derived*>(this))->on_entry(InitEvent(),*this);
-        ::boost::mpl::for_each<initial_states, boost::msm::back::wrap<mpl::placeholders::_1> >
+        ::boost::mpl::for_each<initial_states, boost::msm::wrap<mpl::placeholders::_1> >
             (call_init<InitEvent>(InitEvent(),this));
         // give a chance to handle an anonymous (eventless) transition
         handle_eventless_transitions_helper<library_sm> eventless_helper(this,true);
@@ -652,10 +671,12 @@
 
         HandledEnum ret_handled=HANDLED_FALSE;
         // if the state machine has terminate or interrupt flags, check them, otherwise skip
-        if (is_event_handling_blocked_helper<library_sm,Event>())
+        if (is_event_handling_blocked_helper<Event>
+                ( ::boost::mpl::bool_<has_fsm_blocking_states<library_sm>::type::value>() ) )
             return HANDLED_TRUE;
         // if a message queue is needed and processing is on the way
-        if (!do_pre_msg_queue_helper<library_sm,Event>(evt))
+        if (!do_pre_msg_queue_helper<Event>
+                (evt,::boost::mpl::bool_<is_no_message_queue<library_sm>::type::value>()) )
         {
             // wait for the end of current processing
             return HANDLED_TRUE;
@@ -668,7 +689,8 @@
             handle_defer_helper<library_sm> defer_helper(m_deferred_events_queue);
             defer_helper.do_pre_handle_deferred();
             // process event
-            HandledEnum handled = this->do_process_helper<library_sm,Event>(evt);
+            HandledEnum handled = this->do_process_helper<Event>
+                (evt,::boost::mpl::bool_<is_no_exception_thrown<library_sm>::type::value>());
             if (handled)
             {
                 ret_handled = HANDLED_TRUE;
@@ -678,7 +700,7 @@
 
             // now check if some events were generated in a transition and was not handled
             // because of another processing, and if yes, start handling them
-            do_post_msg_queue_helper<library_sm>();
+            do_post_msg_queue_helper(::boost::mpl::bool_<is_no_message_queue<library_sm>::type::value>());
 
             // event can be handled, processing
             // handle with lowest priority event-less transitions
@@ -702,7 +724,7 @@
         result_state(res),searched_id(id),self(self_) {}
 
         template <class StateType>
-        void operator()(boost::msm::back::wrap<StateType> const&)
+        void operator()(boost::msm::wrap<StateType> const&)
         {
             // look for the state id until found
             BOOST_STATIC_CONSTANT(int, id = (get_state_id<stt,StateType>::value));
@@ -722,7 +744,7 @@
     {
         const BaseState*  result_state=0;
         ::boost::mpl::for_each<state_list, 
-            ::boost::msm::back::wrap< ::boost::mpl::placeholders::_1> > (get_state_id_helper(id,&result_state,this));
+            ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > (get_state_id_helper(id,&result_state,this));
         return result_state;
     }
     // true if the sm is used in another sm
@@ -800,7 +822,7 @@
 
          // History initializer function object, used with mpl::for_each
          template <class State>
-         void operator()(::boost::msm::back::wrap<State> const&)
+         void operator()(::boost::msm::wrap<State> const&)
          {
              m_initial_states[++m_index]=get_state_id<stt,State>::type::value;
          }
@@ -824,7 +846,7 @@
          ,m_substate_list()
      {
          // initialize our list of states with the ones defined in Derived::initial_state
-         ::boost::mpl::for_each< seq_initial_states, ::boost::msm::back::wrap<mpl::placeholders::_1> >
+         ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> >
                         (init_states(m_states));
          m_history.set_initial_states(m_states);
          // create states
@@ -849,7 +871,7 @@
          ,m_visitors()                                                              \
          ,m_substate_list()                                                         \
      {                                                                              \
-         ::boost::mpl::for_each< seq_initial_states, ::boost::msm::back::wrap<mpl::placeholders::_1> > \
+         ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > \
                         (init_states(m_states));                                    \
          m_history.set_initial_states(m_states);                                    \
          fill_states(this);                                                         \
@@ -873,7 +895,7 @@
          ,m_visitors()                                                              \
          ,m_substate_list()                                                         \
      {                                                                              \
-         ::boost::mpl::for_each< seq_initial_states, ::boost::msm::back::wrap<mpl::placeholders::_1> > \
+         ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > \
                         (init_states(m_states));                                    \
          m_history.set_initial_states(m_states);                                    \
          fill_states(this);                                                         \
@@ -915,9 +937,8 @@
 
     // the following 2 functions handle the terminate/interrupt states handling
     // if one of these states is found, the first one is used
-    template <class StateType,class Event>
-    typename ::boost::enable_if<typename has_fsm_blocking_states<StateType>::type,bool >::type
-        is_event_handling_blocked_helper( ::boost::msm::back::dummy<0> = 0)
+    template <class Event>
+    bool is_event_handling_blocked_helper( ::boost::mpl::true_ const &)
     {
         // if the state machine is terminated, do not handle any event
         if (is_flag_active< ::boost::msm::TerminateFlag>())
@@ -930,24 +951,21 @@
         return false;
     }
     // otherwise simple handling, no flag => continue
-    template <class StateType,class Event>
-    typename ::boost::disable_if<typename has_fsm_blocking_states<StateType>::type,bool >::type
-        is_event_handling_blocked_helper( ::boost::msm::back::dummy<1> = 0)
+    template <class Event>
+    bool is_event_handling_blocked_helper( ::boost::mpl::false_ const &)
     {
         // no terminate/interrupt states detected
         return false;
     }
     // the following functions handle pre/post-process handling  of a message queue
     template <class StateType,class EventType>
-    typename ::boost::enable_if<typename is_no_message_queue<StateType>::type,bool >::type
-        do_pre_msg_queue_helper(EventType const& evt, ::boost::msm::back::dummy<0> = 0)
+    bool do_pre_msg_queue_helper(EventType const& evt, ::boost::mpl::true_ const &)
     {
         // no message queue needed
         return true;
     }
     template <class StateType,class EventType>
-    typename ::boost::disable_if<typename is_no_message_queue<StateType>::type,bool >::type
-        do_pre_msg_queue_helper(EventType const& evt, ::boost::msm::back::dummy<1> = 0)
+    bool do_pre_msg_queue_helper(EventType const& evt, ::boost::mpl::false_ const &)
     {
         execute_return (library_sm::*pf) (EventType const& evt) = 
             &library_sm::process_event; 
@@ -956,36 +974,30 @@
         {
             // event has to be put into the queue
             transition_fct f = ::boost::bind(pf,this,evt);
-            m_events_queue.push(f);
+            m_events_queue.m_events_queue.push(f);
             return false;
         }
         // event can be handled, processing
         m_event_processing = true;
         return true;
     }
-    template <class StateType>
-    typename ::boost::enable_if<typename is_no_message_queue<StateType>::type,void >::type
-        do_post_msg_queue_helper( ::boost::msm::back::dummy<0> = 0)
+    void do_post_msg_queue_helper( ::boost::mpl::true_ const &)
     {
         // no message queue needed
     }
-    template <class StateType>
-    typename ::boost::disable_if<typename is_no_message_queue<StateType>::type,void >::type
-        do_post_msg_queue_helper( ::boost::msm::back::dummy<1> = 0)
+    void do_post_msg_queue_helper( ::boost::mpl::false_ const &)
     {
         m_event_processing = false;
-        process_message_queue();
+        process_message_queue(this);
     }
     // the following 2 functions handle the processing either with a try/catch protection or without
     template <class StateType,class EventType>
-    typename ::boost::enable_if<typename is_no_exception_thrown<StateType>::type,HandledEnum >::type
-        do_process_helper(EventType const& evt, ::boost::msm::back::dummy<0> = 0)
+    HandledEnum do_process_helper(EventType const& evt, ::boost::mpl::true_ const &)
     {
         return this->do_process_event(evt);
     }
     template <class StateType,class EventType>
-    typename ::boost::disable_if<typename is_no_exception_thrown<StateType>::type,HandledEnum >::type
-        do_process_helper(EventType const& evt, ::boost::msm::back::dummy<1> = 0)
+    HandledEnum do_process_helper(EventType const& evt, ::boost::mpl::false_ const &)
     {
         try
         {
@@ -1003,7 +1015,7 @@
     template <class StateType, class Enable = void> 
     struct handle_defer_helper
     {
-        handle_defer_helper(deferred_events_queue_t& ){}
+        handle_defer_helper(deferred_msg_queue_helper<library_sm>& ){}
         void do_pre_handle_deferred()
         {
         }
@@ -1017,13 +1029,14 @@
     struct handle_defer_helper
         <StateType, typename enable_if< typename ::boost::msm::back::has_fsm_delayed_events<StateType>::type >::type>
     {
-        handle_defer_helper(deferred_events_queue_t& a_queue):events_queue(a_queue),next_deferred_event(){}
+        handle_defer_helper(deferred_msg_queue_helper<library_sm>& a_queue):
+            events_queue(a_queue),next_deferred_event(){}
         void do_pre_handle_deferred()
         {
-            if (!events_queue.empty())
+            if (!events_queue.m_deferred_events_queue.empty())
             {
-                next_deferred_event = events_queue.back();
-                events_queue.pop_back();
+                next_deferred_event = events_queue.m_deferred_events_queue.back();
+                events_queue.m_deferred_events_queue.pop_back();
             }
         }
 
@@ -1032,7 +1045,7 @@
             if (((handled & HANDLED_DEFERRED) == HANDLED_DEFERRED) && next_deferred_event )
             {
                 // the event was already deferred, no reason to process another deferred event
-                events_queue.push_back(next_deferred_event);
+                events_queue.m_deferred_events_queue.push_back(next_deferred_event);
                 return;
             }
             else if (next_deferred_event)
@@ -1042,8 +1055,8 @@
         }
 
     private:
-        deferred_events_queue_t&    events_queue;
-        deferred_fct                next_deferred_event;
+        deferred_msg_queue_helper<library_sm>&  events_queue;
+        deferred_fct                            next_deferred_event;
     };
 
     // handling of eventless transitions
@@ -1078,6 +1091,69 @@
         bool        handled;
     };
 
+    template <class StateType,class Enable=void>
+    struct region_processing_helper 
+    {
+    public:
+        region_processing_helper(library_sm* self_,HandledEnum& result_)
+            :self(self_),result(result_){}
+        template<class Event>
+        void process(Event const& evt)
+        {
+            // use this table as if it came directly from the user
+            typedef dispatch_table<library_sm,complete_table,Event> table;
+            HandledEnum res =
+                table::instance.entries[self->m_states[0]](
+                *self, 0, self->m_states[0], evt);
+            result = (HandledEnum)((int)result | (int)res);
+        }
+        library_sm*     self;
+        HandledEnum&    result;
+    };
+    // version with visitors
+    template <class StateType>
+    struct region_processing_helper<StateType,typename ::boost::enable_if< 
+                        ::boost::mpl::is_sequence<typename StateType::initial_state> >::type> 
+    {
+        private:
+        // process event in one region
+        template <class region_id,int Dummy=0>
+        struct In
+        {
+            template<class Event>
+            static void process(Event const& evt,library_sm* self_,HandledEnum& result_)
+            {
+                // use this table as if it came directly from the user
+                typedef dispatch_table<library_sm,complete_table,Event> table;
+                HandledEnum res =
+                    table::instance.entries[self_->m_states[region_id::value]](
+                    *self_, region_id::value , self_->m_states[region_id::value], evt);
+                result_ = (HandledEnum)((int)result_ | (int)res);
+                In< ::boost::mpl::int_<region_id::value+1> >::template process(evt,self_,result_);
+            }
+        };
+        template <int Dummy>
+        struct In< ::boost::mpl::int_<nr_regions::value>,Dummy>
+        {
+            // end of processing
+            template<class Event>
+            static void process(Event const& evt,library_sm*,HandledEnum&){}
+        };
+        public:
+        region_processing_helper(library_sm* self_,HandledEnum& result_)
+            :self(self_),result(result_){}
+        template<class Event>
+        void process(Event const& evt)
+        {
+            // use this table as if it came directly from the user
+            typedef dispatch_table<library_sm,complete_table,Event> table;
+            In< ::boost::mpl::int_<0> >::template process(evt,self,result);
+        }
+
+        library_sm*     self;
+        HandledEnum&    result;
+    };
+
     // minimum event processing without exceptions, queues, etc.
     template<class Event>
     HandledEnum do_process_event(Event const& evt)
@@ -1087,14 +1163,9 @@
 
         HandledEnum handled = HANDLED_FALSE;
         // dispatch the event to every region
-        for (int i=0; i<nr_regions::value;++i)
-        {	
-            std::pair<int,HandledEnum> res =
-                table::instance.entries[this->m_states[i]](
-                *this, this->m_states[i], evt);
-            this->m_states[i] = res.first;
-            handled = (HandledEnum)((int)handled | (int)res.second);
-        }
+        region_processing_helper<Derived> helper(this,handled);
+        helper.process(evt);
+
         // if the event has not been handled and we have orthogonal zones, then
         // generate an error on every active state 
         // for state machine states contained in other state machines, do not handle
@@ -1144,7 +1215,7 @@
                 call_init(Event const& an_event,library_sm* self_):
                 evt(an_event),self(self_){}
                 template <class State>
-		void operator()(boost::msm::back::wrap<State> const&)
+		void operator()(boost::msm::wrap<State> const&)
                 {
             execute_entry(::boost::fusion::at_key<State>(self->m_substate_list),evt,*self);
                 }
@@ -1195,25 +1266,13 @@
     private:
         // helper function, helps hiding the forward function for non-state machines states.
         template <class T>
-        typename ::boost::enable_if<
-            typename ::boost::mpl::and_<
-                    typename is_composite_state<T>::type,
-                    typename ::boost::mpl::not_<
-                            typename has_non_forwarding_flag<Flag>::type>::type >::type
-            ,void >::type
-            helper (flag_handler* an_entry,int offset,boost::msm::back::dummy<0> = 0 )
+        void helper (flag_handler* an_entry,int offset, ::boost::mpl::true_ const &  )
         {
             // composite => forward
             an_entry[offset] = &FlagHandler<T,Flag>::forward;
         }
         template <class T>
-        typename ::boost::disable_if<
-            typename ::boost::mpl::and_<
-                    typename is_composite_state<T>::type,
-                    typename ::boost::mpl::not_<
-                            typename has_non_forwarding_flag<Flag>::type>::type >::type
-            ,void >::type
-            helper (flag_handler* an_entry,int offset,boost::msm::back::dummy<1> = 0 )
+        void helper (flag_handler* an_entry,int offset, ::boost::mpl::false_ const &  )
         {
             // default no flag
             an_entry[offset] = &FlagHandler<T,Flag>::flag_false;
@@ -1228,7 +1287,7 @@
 
         // Flags initializer function object, used with mpl::for_each
         template <class StateType>
-        void operator()( ::boost::msm::back::wrap<StateType> const& )
+        void operator()( ::boost::msm::wrap<StateType> const& )
         {
             typedef typename StateType::flag_list flags;
             typedef typename ::boost::mpl::contains<flags,Flag >::type found;
@@ -1243,7 +1302,12 @@
             else
             {
                 // false or forward
-                helper<StateType>(entries,state_id);
+                typedef typename ::boost::mpl::and_<
+                            typename is_composite_state<StateType>::type,
+                            typename ::boost::mpl::not_<
+                                    typename has_non_forwarding_flag<Flag>::type>::type >::type composite_no_forward;
+
+                helper<StateType>(entries,state_id,::boost::mpl::bool_<composite_no_forward::type::value>());
             }
         }
     };
@@ -1255,7 +1319,7 @@
 
         static flag_handler flags_entries[max_state];
         // build a state list
-        ::boost::mpl::for_each<state_list, boost::msm::back::wrap< ::boost::mpl::placeholders::_1> >
+        ::boost::mpl::for_each<state_list, boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                         (init_flags<Flag>(flags_entries));
         return flags_entries;	
     }
@@ -1369,20 +1433,19 @@
             this->new_state_helper<State>(),
             create_state_helper<State>::set_sm(self);
             // create a visitor callback
-            visitor_helper<State>(state_id,::boost::fusion::at_key<State>(self->m_substate_list));
+            visitor_helper(state_id,::boost::fusion::at_key<State>(self->m_substate_list),
+                           ::boost::mpl::bool_<has_accept_sig<State>::type::value>());
         }
     private:
         // support possible use of a visitor if accept_sig is defined
         template <class StateType>
-        typename ::boost::enable_if<typename has_accept_sig<StateType>::type,void >::type
-        visitor_helper(int id,StateType& astate,::boost::msm::back::dummy<0> = 0) const
+        void visitor_helper(int id,StateType& astate, ::boost::mpl::true_ const & ) const
         {
             visitor_args<StateType,StateType::accept_sig::args_number>::
                 template helper<StateType>(self,id,astate);
         }
         template <class StateType>
-        typename ::boost::disable_if<typename has_accept_sig<StateType>::type,void >::type
-            visitor_helper(int ,StateType& ,::boost::msm::back::dummy<1> = 0) const
+        void visitor_helper(int ,StateType& , ::boost::mpl::false_ const &) const
         {
             // nothing to do
         }
@@ -1397,7 +1460,7 @@
          copy_helper(library_sm* sm):
            m_sm(sm){}
          template <class StateType>
-         void operator()( ::boost::msm::back::wrap<StateType> const& )
+         void operator()( ::boost::msm::wrap<StateType> const& )
          {
             BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,StateType>::type::value));
             // possibly also set the visitor
@@ -1422,16 +1485,28 @@
 
          library_sm*	 m_sm;
      };
-
+     // helper to copy the active states attribute
+     template <class region_id,int Dummy=0>
+     struct region_copy_helper
+     {
+         static void do_copy(library_sm* self_,library_sm const& rhs)
+         {
+             self_->m_states[region_id::value] = rhs.m_states[region_id::value];
+             region_copy_helper< ::boost::mpl::int_<region_id::value+1> >::do_copy(self_,rhs);
+         }
+     };
+     template <int Dummy>
+     struct region_copy_helper< ::boost::mpl::int_<nr_regions::value>,Dummy>
+     {
+         // end of processing
+         static void do_copy(library_sm*,library_sm const& ){}
+     };
      // copy functions for deep copy (no need of a 2nd version for NoCopy as noncopyable handles it)
      void do_copy (library_sm const& rhs,
               ::boost::msm::back::dummy<0> = 0)
      {
          // deep copy simply assigns the data
-         for (int i=0; i<nr_regions::value;++i)
-         {
-             m_states[i] = rhs.m_states[i];
-         }
+         region_copy_helper< ::boost::mpl::int_<0> >::do_copy(this,rhs);
          m_events_queue = rhs.m_events_queue;
          m_deferred_events_queue = rhs.m_deferred_events_queue;
          m_history = rhs.m_history;
@@ -1440,7 +1515,7 @@
          m_substate_list = rhs.m_substate_list;
          // except for the states themselves, which get duplicated
 
-         ::boost::mpl::for_each<state_list, ::boost::msm::back::wrap< ::boost::mpl::placeholders::_1> >
+         ::boost::mpl::for_each<state_list, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                         (copy_helper(this));
      }
 
@@ -1475,7 +1550,7 @@
          }
          // iterates through all states to find the one to be activated
          template <class State>
-         void operator()( ::boost::msm::back::wrap<State> const&)
+         void operator()( ::boost::msm::wrap<State> const&)
          {
              entry_exit_helper<Event,is_entry>::template helper< ::boost::mpl::bool_<is_entry>,State >();
          }
@@ -1484,16 +1559,31 @@
          Event const&   evt;
          library_sm*    self;
      };
-     // start for states machines which are themselves embedded in other state machines (composites)
-	 template <class Event>
-     void start(Event const& incomingEvent)
+
+     // helper to start the fsm
+     template <class region_id,int Dummy=0>
+     struct region_start_helper
      {
-         for (int i=0; i<nr_regions::value;++i)
+         template<class Event>
+         static void do_start(library_sm* self_,Event const& incomingEvent)
          {
              //forward the event for handling by sub state machines
-             ::boost::mpl::for_each<state_list, ::boost::msm::back::wrap< ::boost::mpl::placeholders::_1> >
-                 (entry_exit_helper<Event,true>(m_states[i],incomingEvent,this));
+             ::boost::mpl::for_each<state_list, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> >
+                 (entry_exit_helper<Event,true>(self_->m_states[region_id::value],incomingEvent,self_));
          }
+     };
+     template <int Dummy>
+     struct region_start_helper< ::boost::mpl::int_<nr_regions::value>,Dummy>
+     {
+         // end of processing
+         template<class Event>
+         static void do_start(library_sm*,Event const& ){}
+     };
+     // start for states machines which are themselves embedded in other state machines (composites)
+	 template <class Event>
+     void start(Event const& incomingEvent)
+     {
+         region_start_helper< ::boost::mpl::int_<0> >::template do_start(this,incomingEvent);
      }
 
      // helper used to set the correct state as active state upon entry into a fsm
@@ -1546,7 +1636,7 @@
          {
              (static_cast<Derived*>(self))->on_entry(evt,*self);
              ::boost::mpl::for_each<typename EventType::active_state, 
-                                    ::boost::msm::back::wrap< ::boost::mpl::placeholders::_1> >
+                                    ::boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                                                         (fork_helper<EventType>(self,evt));
              // set the correct zones, the others (if any) will be default/history initialized
              self->start(evt.m_event);
@@ -1578,7 +1668,7 @@
              fork_helper(library_sm* self_,EventType const& evt_):
                 helper_self(self_),helper_evt(evt_){}
              template <class StateType>
-             void operator()( ::boost::msm::back::wrap<StateType> const& )
+             void operator()( ::boost::msm::wrap<StateType> const& )
              {
                  int state_id = get_state_id<stt,StateType>::value;
                  BOOST_STATIC_ASSERT(StateType::zone_index >= 0);
@@ -1591,33 +1681,52 @@
          };
      };
 
+     // helper for entry
+     template <class region_id,int Dummy=0>
+     struct region_entry_exit_helper
+     {
+         template<class Event>
+         static void do_entry(library_sm* self_,Event const& incomingEvent)
+         {
+             self_->m_states[region_id::value] = 
+                 self_->m_history.history_entry(incomingEvent)[region_id::value];
+         }
+         template<class Event>
+         static void do_exit(library_sm* self_,Event const& incomingEvent)
+         {
+             ::boost::mpl::for_each<state_list, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> >
+                 (entry_exit_helper<Event,false>(self_->m_states[region_id::value],incomingEvent,self_));
+         }
+     };
+     template <int Dummy>
+     struct region_entry_exit_helper< ::boost::mpl::int_<nr_regions::value>,Dummy>
+     {
+         // end of processing
+         template<class Event>
+         static void do_entry(library_sm*,Event const& ){}
+         template<class Event>
+         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)
      {
         // by default we activate the history/init states, can be overwritten by direct_event_start_helper
-        for (int i=0; i<nr_regions::value;++i)
-        {
-            this->m_states[i] = m_history.history_entry(incomingEvent)[i];
-        }
+        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);
         // handle messages which were generated and blocked in the init calls
         m_event_processing = false;
-        process_message_queue();
+        process_message_queue(this);
      }
          template <class Event>
      void do_exit(Event const& incomingEvent)
      {
-        for (int i=0; i<nr_regions::value;++i)
-        {
-            // first recursively exit the sub machines
-            // forward the event for handling by sub state machines
-            ::boost::mpl::for_each<state_list, ::boost::msm::back::wrap< ::boost::mpl::placeholders::_1> >
-                (entry_exit_helper<Event,false>(m_states[i],incomingEvent,this));
-        }
+        // 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);
         // give the history a chance to handle this (or not).
@@ -1626,45 +1735,52 @@
 
     // no transition for event.
     template <class Event>
-    static std::pair<int,HandledEnum> call_no_transition(library_sm& , int state, Event const& )
+    static HandledEnum call_no_transition(library_sm& , int , int , Event const& )
     {
-        return std::make_pair(state,HANDLED_FALSE);
+        return HANDLED_FALSE;
     }
     // called for deferred events. Address set in the dispatch_table at init
     template <class Event>
-    static std::pair<int,HandledEnum> defer_transition(library_sm& fsm, int state, Event const& e)
+    static HandledEnum defer_transition(library_sm& fsm, int , int , Event const& e)
     {
         execute_return (library_sm::*pf) (Event const& evt)= &library_sm::process_event;
         Event temp (e);
         ::boost::function<execute_return () > f= ::boost::bind(pf, ::boost::ref(fsm),temp);
         fsm.post_deferred_event(f);
-        return std::make_pair(state,HANDLED_DEFERRED);
+        return HANDLED_DEFERRED;
     }
 
     // called for automatic events. Default address set in the dispatch_table at init
     // prevents no-transition detection for automatic events
     template <class Event>
-    static std::pair<int,HandledEnum> default_eventless_transition(library_sm& fsm, int state, Event const& e)
+    static HandledEnum default_eventless_transition(library_sm& fsm, int, int , Event const& e)
     {
-        return std::make_pair(state,HANDLED_FALSE);
+        return HANDLED_FALSE;
     }
 
     // puts a deferred event in the queue
     void post_deferred_event(deferred_fct& deferred)
     {
-        m_deferred_events_queue.push_front(deferred);
+        m_deferred_events_queue.m_deferred_events_queue.push_front(deferred);
     }
     // removes one event from the message queue and processes it
-    void process_message_queue()
+    template <class StateType>
+    typename ::boost::disable_if<typename is_no_message_queue<StateType>::type,void >::type
+    process_message_queue(StateType*)
     {
-        if (!m_events_queue.empty())
+        if (!m_events_queue.m_events_queue.empty())
         {
-            transition_fct to_call = m_events_queue.front();
-            m_events_queue.pop();
+            transition_fct to_call = m_events_queue.m_events_queue.front();
+            m_events_queue.m_events_queue.pop();
             to_call();
         }
     }
-
+    template <class StateType>
+    typename ::boost::enable_if<typename is_no_message_queue<StateType>::type,void >::type
+        process_message_queue(StateType*)
+    {
+        // nothing to process
+    }
     // calls the entry/exit or on_entry/on_exit depending on the state type
     // (avoids calling virtually)
     // variant for FSMs
@@ -1753,20 +1869,32 @@
 
 
 private:
+    template <class StateType,class Enable=void>
+    struct msg_queue_helper 
+    {
+    public:
+        msg_queue_helper():m_events_queue(){}
+        events_queue_t              m_events_queue;
+    };
+    template <class StateType>
+    struct msg_queue_helper<StateType,
+        typename ::boost::enable_if<typename is_no_message_queue<StateType>::type >::type> 
+    {
+    };
+
     template <class Fsm,class Stt, class Event>
     friend struct dispatch_table;
 
     // data members
-    int                         m_states[nr_regions::value];
-    events_queue_t              m_events_queue;
-    deferred_events_queue_t     m_deferred_events_queue;
-    concrete_history            m_history;
-    bool                        m_event_processing;
-    bool                        m_is_included;
-    visitor_fct_helper<BaseState>
-                                m_visitors;
-
-    substate_list               m_substate_list;
+    int                             m_states[nr_regions::value];
+    msg_queue_helper<library_sm>    m_events_queue;
+    deferred_msg_queue_helper
+        <library_sm>                m_deferred_events_queue;
+    concrete_history                m_history;
+    bool                            m_event_processing;
+    bool                            m_is_included;
+    visitor_fct_helper<BaseState>   m_visitors;
+    substate_list                   m_substate_list;
 
 
 };

Modified: sandbox/msm/boost/msm/back/tools.hpp
==============================================================================
--- sandbox/msm/boost/msm/back/tools.hpp	(original)
+++ sandbox/msm/boost/msm/back/tools.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -28,7 +28,7 @@
 {
     fill_state_names(char const** names):m_names(names){}
     template <class StateType>
-    void operator()(boost::msm::back::wrap<StateType> const&)
+    void operator()(boost::msm::wrap<StateType> const&)
     {
         m_names[get_state_id<stt,StateType>::value]= typeid(StateType).name();
     }
@@ -42,7 +42,7 @@
 {
     get_state_name(std::string& name_to_fill, int state_id):m_name(name_to_fill),m_state_id(state_id){}
     template <class StateType>
-    void operator()(boost::msm::back::wrap<StateType> const&)
+    void operator()(boost::msm::wrap<StateType> const&)
     {
         if (get_state_id<stt,StateType>::value == m_state_id)
         {
@@ -58,7 +58,7 @@
 struct display_type 
 {
     template <class Type>
-    void operator()(boost::msm::back::wrap<Type> const&)
+    void operator()(boost::msm::wrap<Type> const&)
     {
         std::cout << typeid(Type).name() << std::endl;
     }

Added: sandbox/msm/boost/msm/common.hpp
==============================================================================
--- (empty file)
+++ sandbox/msm/boost/msm/common.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -0,0 +1,25 @@
+// Copyright 2008 Christophe Henry
+// henry UNDERSCORE christophe AT hotmail DOT com
+// This is an extended version of the state machine available in the boost::mpl library
+// Distributed under the same license as the original.
+// Copyright for the original version:
+// Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
+// under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MSM_COMMON_H
+#define BOOST_MSM_COMMON_H
+
+
+
+namespace boost { namespace msm
+{
+// wrapper for mpl::for_each as showed in the C++ Template Metaprogramming ch. 9
+template <class T>
+struct wrap{};
+
+
+} } // boost::msm
+#endif //BOOST_MSM_COMMON_H
+

Modified: sandbox/msm/boost/msm/front/euml/common.hpp
==============================================================================
--- sandbox/msm/boost/msm/front/euml/common.hpp	(original)
+++ sandbox/msm/boost/msm/front/euml/common.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -11,6 +11,8 @@
 #ifndef BOOST_MSM_FRONT_EUML_COMMON_H
 #define BOOST_MSM_FRONT_EUML_COMMON_H
 
+#include <boost/config.hpp>
+
 #ifdef BOOST_MPL_LIMIT_METAFUNCTION_ARITY
 #undef BOOST_MPL_LIMIT_METAFUNCTION_ARITY
 #endif

Modified: sandbox/msm/boost/msm/front/euml/operator.hpp
==============================================================================
--- sandbox/msm/boost/msm/front/euml/operator.hpp	(original)
+++ sandbox/msm/boost/msm/front/euml/operator.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -18,6 +18,7 @@
 #include <boost/mpl/has_key.hpp>
 #include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/set.hpp>
+#include <boost/type_traits.hpp>
 
 BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
 BOOST_MPL_HAS_XXX_TRAIT_DEF(key_type)

Modified: sandbox/msm/boost/msm/front/euml/state_grammar.hpp
==============================================================================
--- sandbox/msm/boost/msm/front/euml/state_grammar.hpp	(original)
+++ sandbox/msm/boost/msm/front/euml/state_grammar.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -615,6 +615,7 @@
  {};
 
 template <class Expr1,class Expr2,class Attr,class Configure,class BASE>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -640,6 +641,7 @@
 }
 
 template <class Expr1,class Expr2,class Attr,class Configure>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -664,6 +666,7 @@
 }
 
 template <class Expr1,class Expr2,class Attr>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -684,6 +687,7 @@
 }
 
 template <class Expr1,class Expr2>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -702,6 +706,7 @@
 }
 
 template <class Expr1>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -714,6 +719,7 @@
         typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
         return func_state<entry_action,NoAction>();
 }
+inline
 func_state<
 NoAction,
 NoAction
@@ -785,6 +791,7 @@
 };
 
 template <class STT,class Init>
+inline
 func_state_machine<
 STT,
 typename boost::result_of<BuildInit(Init)>::type
@@ -796,6 +803,7 @@
 }
 
 template <class STT,class Init,class Expr1>
+inline
 func_state_machine<
 STT,
 typename boost::result_of<BuildInit(Init)>::type,
@@ -812,6 +820,7 @@
 }
 
 template <class STT,class Init,class Expr1,class Expr2>
+inline
 func_state_machine<
 STT,
 typename boost::result_of<BuildInit(Init)>::type,
@@ -833,6 +842,7 @@
 }
 
 template <class STT,class Init,class Expr1,class Expr2,class Attr>
+inline
 func_state_machine<
 STT,
 typename boost::result_of<BuildInit(Init)>::type,
@@ -856,6 +866,7 @@
 }
 
 template <class STT,class Init,class Expr1,class Expr2,class Attr,class Configure>
+inline
 func_state_machine<
 STT,
 typename boost::result_of<BuildInit(Init)>::type,
@@ -887,6 +898,7 @@
 }
 
 template <class STT,class Init,class Expr1,class Expr2,class Attr,class Configure,class Expr3>
+inline
 func_state_machine<
 STT,
 typename boost::result_of<BuildInit(Init)>::type,
@@ -922,6 +934,7 @@
 }
 
 template <class STT,class Init,class Expr1,class Expr2,class Attr,class Configure,class Expr3,class Expr4>
+inline
 func_state_machine<
 STT,
 typename boost::result_of<BuildInit(Init)>::type,
@@ -962,6 +975,7 @@
 }
 
 template <class STT,class Init,class Expr1,class Expr2,class Attr,class Configure,class Expr3,class Expr4,class BASE>
+inline
 func_state_machine<
 STT,
 typename boost::result_of<BuildInit(Init)>::type,
@@ -1003,6 +1017,7 @@
 }
 
 template <class Expr>
+inline
 inherit_attributes<typename boost::result_of<BuildAttributes(Expr)>::type>
 build_attributes (Expr const&)
 {
@@ -1010,6 +1025,7 @@
 }
 
 template <class Expr1,class Expr2,class Attr,class Configure,class BASE>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1038,6 +1054,7 @@
 }
 
 template <class Expr1,class Expr2,class Attr,class Configure>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1066,6 +1083,7 @@
 }
 
 template <class Expr1,class Expr2,class Attr>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1087,6 +1105,7 @@
 }
 
 template <class Expr1,class Expr2>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1108,6 +1127,7 @@
 }
 
 template <class Expr1>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1122,6 +1142,7 @@
         typedef typename boost::result_of<BuildActionSequence(Expr1)>::type entry_action;
         return func_state<entry_action,NoAction,::boost::fusion::vector<>,::boost::mpl::vector<boost::msm::TerminateFlag> >();
 }
+inline
 func_state<
 NoAction,
 NoAction,
@@ -1134,6 +1155,7 @@
 }
 
 template <class Expr1,class Expr2,class Attr,class Configure,class BASE,class EndInterruptEvent>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1168,6 +1190,7 @@
 }
 
 template <class Expr1,class Expr2,class Attr,class Configure,class EndInterruptEvent>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1203,6 +1226,7 @@
 }
 
 template <class Expr1,class Expr2,class Attr,class EndInterruptEvent>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1225,6 +1249,7 @@
 }
 
 template <class Expr1,class Expr2,class EndInterruptEvent>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1247,6 +1272,7 @@
 }
 
 template <class Expr1,class EndInterruptEvent>
+inline
 func_state<
 typename ::boost::mpl::eval_if<
     typename proto::matches<Expr1,BuildActionSequence>::type,
@@ -1264,6 +1290,7 @@
 }
 
 template <class EndInterruptEvent>
+inline
 func_state<
 NoAction,
 NoAction,
@@ -1277,6 +1304,7 @@
 }
 
 template <int ZoneIndex,class Expr1,class Expr2,class Attr,class Configure,class BASE>
+inline
 entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1303,6 +1331,7 @@
 }
 
 template <int ZoneIndex,class Expr1,class Expr2,class Attr,class Configure>
+inline
 entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1328,6 +1357,7 @@
 }
 
 template <int ZoneIndex,class Expr1,class Expr2,class Attr>
+inline
 entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1349,6 +1379,7 @@
 }
 
 template <int ZoneIndex,class Expr1,class Expr2>
+inline
 entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1368,6 +1399,7 @@
 }
 
 template <int ZoneIndex,class Expr1>
+inline
 entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1383,6 +1415,7 @@
 }
 
 template <int ZoneIndex>
+inline
 entry_func_state<
 ZoneIndex,
 NoAction,
@@ -1394,6 +1427,7 @@
 }
 
 template <class Event,class Expr1,class Expr2,class Attr,class Configure,class BASE>
+inline
 exit_func_state<
 Event,
 typename ::boost::mpl::eval_if<
@@ -1420,6 +1454,7 @@
 }
 
 template <class Event,class Expr1,class Expr2,class Attr,class Configure>
+inline
 exit_func_state<
 Event,
 typename ::boost::mpl::eval_if<
@@ -1445,6 +1480,7 @@
 }
 
 template <class Event,class Expr1,class Expr2,class Attr>
+inline
 exit_func_state<
 Event,
 typename ::boost::mpl::eval_if<
@@ -1466,6 +1502,7 @@
 }
 
 template <class Event,class Expr1,class Expr2>
+inline
 exit_func_state<
 Event,
 typename ::boost::mpl::eval_if<
@@ -1485,6 +1522,7 @@
 }
 
 template <class Event,class Expr1>
+inline
 exit_func_state<
 Event,
 typename ::boost::mpl::eval_if<
@@ -1500,6 +1538,7 @@
 }
 
 template <class Event>
+inline
 exit_func_state<
 Event,
 NoAction,
@@ -1511,6 +1550,7 @@
 }
 
 template <int ZoneIndex,class Expr1,class Expr2,class Attr,class Configure,class BASE>
+inline
 explicit_entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1537,6 +1577,7 @@
 }
 
 template <int ZoneIndex,class Expr1,class Expr2,class Attr,class Configure>
+inline
 explicit_entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1562,6 +1603,7 @@
 }
 
 template <int ZoneIndex,class Expr1,class Expr2,class Attr>
+inline
 explicit_entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1583,6 +1625,7 @@
 }
 
 template <int ZoneIndex,class Expr1,class Expr2>
+inline
 explicit_entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1602,6 +1645,7 @@
 }
 
 template <int ZoneIndex,class Expr1>
+inline
 explicit_entry_func_state<
 ZoneIndex,
 typename ::boost::mpl::eval_if<
@@ -1617,6 +1661,7 @@
 }
 
 template <int ZoneIndex>
+inline
 explicit_entry_func_state<
 ZoneIndex,
 NoAction,

Modified: sandbox/msm/boost/msm/front/functor_row.hpp
==============================================================================
--- sandbox/msm/boost/msm/front/functor_row.hpp	(original)
+++ sandbox/msm/boost/msm/front/functor_row.hpp	2009-12-18 17:27:59 EST (Fri, 18 Dec 2009)
@@ -16,6 +16,8 @@
 
 #include <boost/typeof/typeof.hpp>
 
+#include <boost/msm/row_tags.hpp>
+#include <boost/msm/common.hpp>
 #include <boost/msm/front/automatic_event.hpp>
 
 #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
@@ -120,7 +122,7 @@
             Call(EVT const& evt,FSM& fsm,STATE& state):
         evt_(evt),fsm_(fsm),state_(state){}
         template <class FCT>
-        void operator()(::boost::msm::back::wrap<FCT> const& )
+        void operator()(::boost::msm::wrap<FCT> const& )
         {
             FCT()(evt_,fsm_,state_);
         }
@@ -140,7 +142,7 @@
             Call2(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt):
         evt_(evt),fsm_(fsm),src_(src),tgt_(tgt){}
         template <class FCT>
-        void operator()(::boost::msm::back::wrap<FCT> const& )
+        void operator()(::boost::msm::wrap<FCT> const& )
         {
             FCT()(evt_,fsm_,src_,tgt_);
         }
@@ -156,13 +158,13 @@
         template <class EVT,class FSM,class STATE>
         void operator()(EVT const& evt,FSM& fsm,STATE& state)
         {
-            mpl::for_each<Sequence,boost::msm::back::wrap< ::boost::mpl::placeholders::_1> >
+            mpl::for_each<Sequence,boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                 (Call<EVT,FSM,STATE>(evt,fsm,state));
         }
         template <class EVT,class FSM,class SourceState,class TargetState>
         void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)
         {
-            mpl::for_each<Sequence,boost::msm::back::wrap< ::boost::mpl::placeholders::_1> >
+            mpl::for_each<Sequence,boost::msm::wrap< ::boost::mpl::placeholders::_1> >
                 (Call2<EVT,FSM,SourceState,TargetState>(evt,fsm,src,tgt));
         }
     };