Added boost header

test/external/boost/msm/active_state_switching_policies.hpp

@@ -0,0 +1,55 @@
+// 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_ACTIVE_STATE_SWITCHING_POLICIES_H
+#define BOOST_MSM_ACTIVE_STATE_SWITCHING_POLICIES_H
+
+namespace boost { namespace msm
+{
+// policy classes
+
+// Default: new active state set after the transition (after entry)
+struct active_state_switch_after_entry 
+{
+    static int after_guard(int current_state,int){return current_state;}
+    static int after_exit(int current_state,int){return current_state;}
+    static int after_action(int current_state,int){return current_state;}
+    static int after_entry(int,int next_state){return next_state;}
+};
+
+// new state set before the transition starts
+struct active_state_switch_before_transition 
+{
+    static int after_guard(int,int next_state){return next_state;}
+    static int after_exit(int,int next_state){return next_state;}
+    static int after_action(int,int next_state){return next_state;}
+    static int after_entry(int,int next_state){return next_state;}
+};
+
+// new state set after exit action completed
+struct active_state_switch_after_exit 
+{
+    static int after_guard(int current_state,int){return current_state;}
+    static int after_exit(int,int next_state){return next_state;}
+    static int after_action(int,int next_state){return next_state;}
+    static int after_entry(int,int next_state){return next_state;}
+};
+
+// new state set after transition action completed
+struct active_state_switch_after_transition_action 
+{
+    static int after_guard(int current_state,int){return current_state;}
+    static int after_exit(int current_state,int){return current_state;}
+    static int after_action(int,int next_state){return next_state;}
+    static int after_entry(int,int next_state){return next_state;}
+};
+
+} }//boost::msm
+#endif //BOOST_MSM_ACTIVE_STATE_SWITCHING_POLICIES_H

test/external/boost/msm/back/args.hpp

@@ -0,0 +1,68 @@
+// 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_BACK_ARGS_H
+#define BOOST_MSM_BACK_ARGS_H
+
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/control/expr_if.hpp> 
+#include <boost/preprocessor/punctuation/comma.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/comparison/less.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/function.hpp>
+
+#ifndef BOOST_MSM_VISITOR_ARG_SIZE
+#define BOOST_MSM_VISITOR_ARG_SIZE 2 // default max number of arguments
+#endif
+
+namespace boost { namespace msm { namespace back
+{
+struct no_args {};
+#define MSM_ARGS_TYPEDEF_SUB(z, n, unused) typedef ARG ## n argument ## n ;
+#define MSM_ARGS_PRINT(z, n, data) data
+#define MSM_ARGS_NONE_PRINT(z, n, data) class data ## n = no_args                          \
+    BOOST_PP_COMMA_IF( BOOST_PP_LESS(n, BOOST_PP_DEC(BOOST_MSM_VISITOR_ARG_SIZE) ) )                  
+
+#define MSM_VISITOR_MAIN_ARGS(n)                                                        \
+    template <class RES,                                                                \
+              BOOST_PP_REPEAT(BOOST_MSM_VISITOR_ARG_SIZE, MSM_ARGS_NONE_PRINT, ARG)>    \
+    struct args                                                                         \
+    {                                                                                   \
+        typedef ::boost::function<RES(BOOST_PP_ENUM_PARAMS(n, ARG))> type;              \
+        enum {args_number=n};                                                           \
+        BOOST_PP_REPEAT(n, MSM_ARGS_TYPEDEF_SUB, ~ )                                    \
+    };
+
+#define MSM_VISITOR_ARGS(z, n, unused)                                                              \
+    template <class RES BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class ARG)>                    \
+    struct args<RES,                                                                                \
+                BOOST_PP_ENUM_PARAMS(n,ARG)                                                         \
+                BOOST_PP_COMMA_IF(n)                                                                \
+                BOOST_PP_ENUM(BOOST_PP_SUB(BOOST_MSM_VISITOR_ARG_SIZE,n), MSM_ARGS_PRINT, no_args)     \
+                >                                                                                   \
+    {                                                                                               \
+        typedef ::boost::function<RES(BOOST_PP_ENUM_PARAMS(n, ARG))> type;                          \
+        enum {args_number=n};                                                                       \
+        BOOST_PP_REPEAT(n, MSM_ARGS_TYPEDEF_SUB, ~ )                                                \
+    };
+MSM_VISITOR_MAIN_ARGS(BOOST_MSM_VISITOR_ARG_SIZE)
+BOOST_PP_REPEAT(BOOST_MSM_VISITOR_ARG_SIZE, MSM_VISITOR_ARGS, ~)
+
+#undef MSM_VISITOR_ARGS
+#undef MSM_ARGS_PRINT
+
+}}}
+
+#endif //BOOST_MSM_BACK_ARGS_H
+

test/external/boost/msm/back/bind_helpers.hpp

@@ -0,0 +1,41 @@
+// 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_BACK_BIND_HELPERS_H
+#define BOOST_MSM_BACK_BIND_HELPERS_H
+
+#include <functional>
+
+namespace boost { namespace msm { namespace back
+{
+    // 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);
+        }
+    };
+    // 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;
+        }
+    };
+} } }//boost::msm::back
+#endif //BOOST_MSM_BACK_BIND_HELPERS_H

test/external/boost/msm/back/common_types.hpp

@@ -0,0 +1,35 @@
+// 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_TYPES_H
+#define BOOST_MSM_COMMON_TYPES_H
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/msm/common.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+// used for disable_if
+template <int> struct dummy { dummy(int) {} };
+// return value for transition handling
+typedef enum
+{
+    HANDLED_FALSE=0,
+    HANDLED_TRUE =1,
+    HANDLED_GUARD_REJECT=2,
+    HANDLED_DEFERRED=4
+} HandledEnum;
+
+typedef HandledEnum execute_return;
+
+}}}
+
+#endif //BOOST_MSM_COMMON_TYPES_H
+

test/external/boost/msm/back/copy_policies.hpp

@@ -0,0 +1,30 @@
+// 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_BACK_COPY_POLICIES_H
+#define BOOST_MSM_BACK_COPY_POLICIES_H
+
+#include <boost/noncopyable.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+    // deactivates copy
+    struct NoCopy : ::boost::noncopyable
+    {
+    };
+    
+    // allows deep copy
+    struct DeepCopy
+    {
+    };
+} } }//boost::msm::back
+
+
+#endif //BOOST_MSM_BACK_COPY_POLICIES_H

test/external/boost/msm/back/default_compile_policy.hpp

@@ -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_BACK_DEFAULT_COMPILE_POLICY_HPP
+#define BOOST_MSM_BACK_DEFAULT_COMPILE_POLICY_HPP
+
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+struct favor_runtime_speed 
+{
+    typedef int compile_policy;
+    typedef ::boost::mpl::true_ add_forwarding_rows;
+};
+
+}}}// boost::msm::back
+#endif // BOOST_MSM_BACK_DEFAULT_COMPILE_POLICY_HPP

test/external/boost/msm/back/dispatch_table.hpp

@@ -0,0 +1,361 @@
+// 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_BACK_DISPATCH_TABLE_H
+#define BOOST_MSM_BACK_DISPATCH_TABLE_H
+
+#include <utility>
+
+#include <boost/mpl/reverse_fold.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/filter_view.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/advance.hpp>
+
+#include <boost/type_traits/is_base_of.hpp>
+
+#include <boost/msm/back/metafunctions.hpp>
+#include <boost/msm/back/common_types.hpp>
+
+BOOST_MPL_HAS_XXX_TRAIT_DEF(is_frow)
+
+namespace boost { namespace msm { namespace back 
+{
+
+// Generates a singleton runtime lookup table that maps current state
+// to a function that makes the SM take its transition on the given
+// Event type.
+template <class Fsm,class Stt, class Event,class CompilePolicy>
+struct dispatch_table
+{
+ private:
+    // This is a table of these function pointers.
+    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
+    // (like an UML diamond). Allows transition conflicts.
+    template< typename Seq,typename AnEvent,typename State >
+    struct chain_row
+    {
+        typedef State   current_state_type;
+        typedef AnEvent transition_event;
+
+        // helper for building a disable/enable_if-controlled execute function
+        struct execute_helper
+        {
+            template <class Sequence>
+            static
+            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 HANDLED_FALSE;
+            }
+
+            template <class Sequence>
+            static
+            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;
+                 HandledEnum res = first_row::execute(fsm,region_index,state,evt);
+                 if (HANDLED_TRUE!=res)
+                 {
+                    // if the first rejected, move on to the next one
+                    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
+                    if ((HANDLED_FALSE==sub_res) && (HANDLED_GUARD_REJECT==res) )
+                        return HANDLED_GUARD_REJECT;
+                    else
+                        return sub_res;
+                 }
+                 return res;
+            }
+        };
+        // Take the transition action and return the next state.
+        static HandledEnum execute(Fsm& fsm, int region_index, int state, Event const& evt)
+        {
+            // forward to helper
+            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
+    template< typename Entry > 
+    struct make_chain_row_from_map_entry
+    { 
+        // if we have more than one frow with the same state as source, remove the ones extra
+        // note: we know the frow's are located at the beginning so we remove at the beginning (number of frows - 1) elements
+        enum {number_frows = ::boost::mpl::count_if< typename Entry::second,has_is_frow< ::boost::mpl::placeholders::_1> >::value};
+
+        //erases the first NumberToDelete rows
+        template<class Sequence, int NumberToDelete>
+        struct erase_first_rows
+        {
+            typedef typename ::boost::mpl::erase<
+                typename Entry::second,
+                typename ::boost::mpl::begin<Sequence>::type,
+                typename ::boost::mpl::advance<
+                        typename ::boost::mpl::begin<Sequence>::type, 
+                        ::boost::mpl::int_<NumberToDelete> >::type
+            >::type type;
+        };
+        // if we have more than 1 frow with this event (not allowed), delete the spare
+        typedef typename ::boost::mpl::eval_if<
+            typename ::boost::mpl::bool_< number_frows >= 2 >::type,
+            erase_first_rows<typename Entry::second,number_frows-1>,
+            ::boost::mpl::identity<typename Entry::second>
+        >::type filtered_stt;
+
+        typedef chain_row<filtered_stt,Event,
+            typename Entry::first > type;
+    }; 
+    // helper for lazy evaluation in eval_if of change_frow_event
+    template <class Transition,class NewEvent>
+    struct replace_event
+    {
+        typedef typename Transition::template replace_event<NewEvent>::type type;
+    };
+    // changes the event type for a frow to the event we are dispatching
+    // this helps ensure that an event does not get processed more than once because of frows and base events.
+    template <class FrowTransition>
+    struct change_frow_event
+    {
+        typedef typename ::boost::mpl::eval_if<
+            typename has_is_frow<FrowTransition>::type,
+            replace_event<FrowTransition,Event>,
+            boost::mpl::identity<FrowTransition>
+        >::type type;
+    };
+    // Compute the maximum state value in the sm so we know how big
+    // to make the table
+    typedef typename generate_state_set<Stt>::type state_list;
+    BOOST_STATIC_CONSTANT(int, max_state = ( ::boost::mpl::size<state_list>::value));
+
+    // A function object for use with mpl::for_each that stuffs
+    // transitions into cells.
+    struct init_cell
+    {
+        init_cell(dispatch_table* self_)
+          : self(self_)
+        {}
+        // version for transition event not base of our event
+        // first for all transitions, then for internal ones of a fsm
+        template <class Transition>
+        typename ::boost::disable_if<
+            typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type
+        ,void>::type
+        init_event_base_case(Transition const&, ::boost::mpl::true_ const &) const
+        {
+            typedef typename create_stt<Fsm>::type stt; 
+            BOOST_STATIC_CONSTANT(int, state_id = 
+                (get_state_id<stt,typename Transition::current_state_type>::value));
+            self->entries[state_id+1] = reinterpret_cast<cell>(&Transition::execute);
+        }
+        template <class Transition>
+        typename ::boost::enable_if<
+            typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type
+        ,void>::type
+        init_event_base_case(Transition const&, ::boost::mpl::true_ const &) const
+        {
+            self->entries[0] = reinterpret_cast<cell>(&Transition::execute);
+        }
+
+        // version for transition event base of our event
+        // first for all transitions, then for internal ones of a fsm
+        template <class Transition>
+        typename ::boost::disable_if<
+            typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type
+        ,void>::type
+        init_event_base_case(Transition const&, ::boost::mpl::false_ const &) const
+        {
+            typedef typename create_stt<Fsm>::type stt; 
+            BOOST_STATIC_CONSTANT(int, state_id = 
+                (get_state_id<stt,typename Transition::current_state_type>::value));
+            self->entries[state_id+1] = &Transition::execute;
+        }
+        template <class Transition>
+        typename ::boost::enable_if<
+            typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type
+        ,void>::type
+        init_event_base_case(Transition const&, ::boost::mpl::false_ const &) const
+        {
+            self->entries[0] = &Transition::execute;
+        }
+        // Cell initializer function object, used with mpl::for_each
+        template <class Transition>
+        typename ::boost::enable_if<typename has_not_real_row_tag<Transition>::type,void >::type
+            operator()(Transition const&,boost::msm::back::dummy<0> = 0) const
+        {
+            // version for not real rows. No problem because irrelevant for process_event
+        }
+        template <class Transition>
+        typename ::boost::disable_if<typename has_not_real_row_tag<Transition>::type,void >::type
+        operator()(Transition const& tr,boost::msm::back::dummy<1> = 0) const
+        {
+            //only if the transition event is a base of our event is the reinterpret_case safe
+            init_event_base_case(tr,
+                ::boost::mpl::bool_< 
+                    ::boost::is_base_of<typename Transition::transition_event,Event>::type::value>() );
+        }
+    
+        dispatch_table* self;
+    };
+
+    // Cell default-initializer function object, used with mpl::for_each
+    // initializes with call_no_transition, defer_transition or default_eventless_transition
+    // variant for non-anonymous transitions
+    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_)
+        {}
+        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+1] = call_no_transition;
+        }
+        template <class State>
+        typename ::boost::disable_if<
+            typename ::boost::mpl::or_<
+                typename has_state_delayed_event<State,Event>::type,
+                typename ::boost::is_same<State,Fsm>::type
+            >::type
+        ,void >::type
+        operator()(boost::msm::wrap<State> const&,boost::msm::back::dummy<1> = 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::call_no_transition;
+            tofill_entries[state_id+1] = call_no_transition;
+        }
+        // case for internal transitions of this fsm
+        template <class State>
+        typename ::boost::enable_if<
+            typename ::boost::mpl::and_<
+                typename ::boost::mpl::not_<typename has_state_delayed_event<State,Event>::type>::type,
+                typename ::boost::is_same<State,Fsm>::type
+            >::type
+        ,void>::type
+        operator()(boost::msm::wrap<State> const&,boost::msm::back::dummy<2> = 0)
+        {
+            cell call_no_transition = &Fsm::call_no_transition_internal;
+            tofill_entries[0] = call_no_transition;
+        }
+        dispatch_table* self;
+        cell* tofill_entries;
+    };
+
+    // variant for anonymous transitions
+    template <class EventType>
+    struct default_init_cell<EventType,
+                             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_)
+        {}
+
+        // 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>
+        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+1] = call_no_transition;
+        }
+
+        dispatch_table* self;
+        cell* tofill_entries;
+    };
+
+ public:
+    // initialize the dispatch table for a given Event and Fsm
+    dispatch_table()
+    {
+        // Initialize cells for no transition
+        ::boost::mpl::for_each<typename generate_state_set<Stt>::type, 
+                               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
+        // first we build a map of sequence for every source
+        // in reverse order so that the frow's are handled first (UML priority)
+        typedef typename ::boost::mpl::reverse_fold<
+                        // filter on event
+                        ::boost::mpl::filter_view
+                            <Stt, ::boost::is_base_of<transition_event< ::boost::mpl::placeholders::_>, Event> >,
+                        // build a map
+                        ::boost::mpl::map<>,
+                        ::boost::mpl::if_<
+                            // if we already have a row on this source state
+                            ::boost::mpl::has_key< ::boost::mpl::placeholders::_1,
+                                                   transition_source_type< ::boost::mpl::placeholders::_2> >,
+                            // insert a new element in the value type
+                            ::boost::mpl::insert< 
+                                ::boost::mpl::placeholders::_1,
+                                ::boost::mpl::pair<transition_source_type< ::boost::mpl::placeholders::_2>,
+                                                   ::boost::mpl::push_back< 
+                                                        ::boost::mpl::at< ::boost::mpl::placeholders::_1,
+                                                        transition_source_type< ::boost::mpl::placeholders::_2> >,
+                                                        change_frow_event< ::boost::mpl::placeholders::_2 > > 
+                                                   > >,
+                            // first row on this source state, make a vector with 1 element
+                            ::boost::mpl::insert< 
+                                        ::boost::mpl::placeholders::_1,
+                                        ::boost::mpl::pair<transition_source_type< ::boost::mpl::placeholders::_2>,
+                                        make_vector< change_frow_event< ::boost::mpl::placeholders::_2> > > >
+                               >
+                       >::type map_of_row_seq;
+        // and then build chaining rows for all source states having more than 1 row
+        typedef typename ::boost::mpl::fold<
+            map_of_row_seq,::boost::mpl::vector0<>,
+            ::boost::mpl::if_<
+                     ::boost::mpl::greater< ::boost::mpl::size< 
+                                                    ::boost::mpl::second< ::boost::mpl::placeholders::_2> >,
+                                            ::boost::mpl::int_<1> >,
+                     // we need row chaining
+                     ::boost::mpl::push_back< ::boost::mpl::placeholders::_1, 
+                                    make_chain_row_from_map_entry< ::boost::mpl::placeholders::_2> >,
+                     // just one row, no chaining, we rebuild the row like it was before
+                     ::boost::mpl::push_back< ::boost::mpl::placeholders::_1, 
+                                              get_first_element_pair_second< ::boost::mpl::placeholders::_2> > 
+             > >::type chained_rows; 
+        // Go back and fill in cells for matching transitions.
+        ::boost::mpl::for_each<chained_rows>(init_cell(this));
+    }
+
+    // The singleton instance.
+    static const dispatch_table instance;
+
+ public: // data members
+     // +1 => 0 is reserved for this fsm (internal transitions)
+    cell entries[max_state+1];
+};
+
+}}} // boost::msm::back
+
+
+#endif //BOOST_MSM_BACK_DISPATCH_TABLE_H
+

test/external/boost/msm/back/favor_compile_time.hpp

@@ -0,0 +1,319 @@
+// 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_BACK_FAVOR_COMPILE_TIME_H
+#define BOOST_MSM_BACK_FAVOR_COMPILE_TIME_H
+
+#include <utility>
+#include <deque>
+
+#include <boost/mpl/filter_view.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/any.hpp>
+
+#include <boost/msm/common.hpp>
+#include <boost/msm/back/metafunctions.hpp>
+#include <boost/msm/back/common_types.hpp>
+#include <boost/msm/back/dispatch_table.hpp>
+
+namespace boost { namespace msm { namespace back 
+{
+
+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));
+        }
+    }
+private:
+    msm::back::HandledEnum&     res;
+    Fsm*                        self;
+    ::boost::any                any_event;
+    bool                        finished;
+};
+
+#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 stt_events;                       \
+        typedef ::boost::msm::back::recursive_get_internal_transition_table<fsmname, ::boost::mpl::true_ >::type istt;    \
+        typedef ::boost::msm::back::generate_event_set<create_real_stt<fsmname,istt>::type >::type istt_events;  \
+        typedef ::boost::msm::back::set_insert_range<stt_events,istt_events>::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 int compile_policy;
+    typedef ::boost::mpl::false_ add_forwarding_rows;
+};
+
+// Generates a singleton runtime lookup table that maps current state
+// to a function that makes the SM take its transition on the given
+// Event type.
+template <class Fsm,class Stt, class Event>
+struct dispatch_table < Fsm, Stt, Event, ::boost::msm::back::favor_compile_time>
+{
+ private:
+    // This is a table of these function pointers.
+    typedef HandledEnum (*cell)(Fsm&, int,int,Event const&);
+    typedef bool (*guard)(Fsm&, Event const&);
+
+    // Compute the maximum state value in the sm so we know how big
+    // to make the table
+    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);
+                // reject is considered as erasing an error (HANDLED_FALSE)
+                if ((HANDLED_FALSE==handled) && (HANDLED_GUARD_REJECT==res) )
+                    res = HANDLED_GUARD_REJECT;
+                else
+                    res = 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)
+    {
+        return (fsm.template get_state<TransitionState&>()).process_any_event( ::boost::any(evt));
+    }
+    // A function object for use with mpl::for_each that stuffs
+    // transitions into cells.
+    struct init_cell
+    {
+        init_cell(dispatch_table* self_)
+          : self(self_)
+        {}
+        // version for transition event not base of our event
+        template <class Transition>
+        typename ::boost::disable_if<
+            typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type
+        ,void>::type
+        init_event_base_case(Transition const&, ::boost::mpl::true_ const &) const
+        {
+            typedef typename create_stt<Fsm>::type stt; 
+            BOOST_STATIC_CONSTANT(int, state_id = 
+                (get_state_id<stt,typename Transition::current_state_type>::value));
+            self->entries[state_id+1].one_state.push_front(reinterpret_cast<cell>(&Transition::execute));
+        }
+        template <class Transition>
+        typename ::boost::enable_if<
+            typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type
+        ,void>::type
+        init_event_base_case(Transition const&, ::boost::mpl::true_ const &) const
+        {
+            self->entries[0].one_state.push_front(reinterpret_cast<cell>(&Transition::execute));
+        }
+
+        // version for transition event base of our event
+        template <class Transition>
+        typename ::boost::disable_if<
+            typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type
+        ,void>::type
+        init_event_base_case(Transition const&, ::boost::mpl::false_ const &) const
+        {
+            typedef typename create_stt<Fsm>::type stt; 
+            BOOST_STATIC_CONSTANT(int, state_id = 
+                (get_state_id<stt,typename Transition::current_state_type>::value));
+            self->entries[state_id+1].one_state.push_front(&Transition::execute);
+        }
+        template <class Transition>
+        typename ::boost::enable_if<
+            typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type
+        ,void>::type
+        init_event_base_case(Transition const&, ::boost::mpl::false_ const &) const
+        {
+            self->entries[0].one_state.push_front(&Transition::execute);
+        }
+        // Cell initializer function object, used with mpl::for_each
+        template <class Transition>
+        typename ::boost::enable_if<typename has_not_real_row_tag<Transition>::type,void >::type
+            operator()(Transition const&,boost::msm::back::dummy<0> = 0) const
+        {
+            // version for not real rows. No problem because irrelevant for process_event
+        }
+        template <class Transition>
+        typename ::boost::disable_if<typename has_not_real_row_tag<Transition>::type,void >::type
+        operator()(Transition const& tr,boost::msm::back::dummy<1> = 0) const
+        {
+            //only if the transition event is a base of our event is the reinterpret_case safe
+            init_event_base_case(tr,
+                ::boost::mpl::bool_< 
+                    ::boost::is_base_of<typename Transition::transition_event,Event>::type::value>() );
+        }
+    
+        dispatch_table* self;
+    };
+
+    // Cell default-initializer function object, used with mpl::for_each
+    // initializes with call_no_transition, defer_transition or default_eventless_transition
+    // variant for non-anonymous transitions
+    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+1].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+1].one_state.push_back(call_no_transition);
+            }
+        };
+        template <int some_dummy> struct helper<false,true,some_dummy> 
+        {
+            template <class State>
+            static
+            typename ::boost::enable_if<
+                typename ::boost::is_same<State,Fsm>::type
+            ,void>::type
+            execute(boost::msm::wrap<State> const&,chain_row* tofill,boost::msm::back::dummy<0> = 0)
+            {
+                // for internal tables
+                cell call_no_transition_internal = &Fsm::call_no_transition;
+                tofill[0].one_state.push_front(call_no_transition_internal);
+            }
+            template <class State>
+            static
+            typename ::boost::disable_if<
+                typename ::boost::is_same<State,Fsm>::type
+            ,void>::type
+            execute(boost::msm::wrap<State> const&,chain_row* tofill,boost::msm::back::dummy<1> = 0)
+            {
+                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+1].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+1].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
+    template <class EventType>
+    struct default_init_cell<EventType,
+                             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_)
+        {}
+
+        // 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>
+        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+1].one_state.push_back(call_no_transition);
+        }
+
+        dispatch_table* self;
+        chain_row* tofill_entries;
+    };
+
+ public:
+    // initialize the dispatch table for a given Event and Fsm
+    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<
+            typename generate_state_set<Stt>::type, 
+            boost::msm::wrap< ::boost::mpl::placeholders::_1> >
+         (default_init_cell<Event>(this,entries));
+
+    }
+
+    // The singleton instance.
+    static const dispatch_table instance;
+
+ public: // data members
+     chain_row entries[max_state+1];
+};
+
+template <class Fsm,class Stt, class Event>
+const boost::msm::back::dispatch_table<Fsm,Stt, Event,favor_compile_time>
+dispatch_table<Fsm,Stt, Event,favor_compile_time>::instance;
+
+}}} // boost::msm::back
+
+#endif //BOOST_MSM_BACK_FAVOR_COMPILE_TIME_H

test/external/boost/msm/back/fold_to_list.hpp

@@ -0,0 +1,77 @@
+// Copyright 2008 Christophe Henry
+// henry UNDERSCORE christophe AT hotmail DOT com
+// This is taken from Boost.Proto's documentation
+// Copyright for the original version:
+// Copyright 2008 Eric Niebler. 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_BACK_FOLD_TO_LIST_H
+#define BOOST_MSM_BACK_FOLD_TO_LIST_H
+
+#include <boost/msm/proto_config.hpp>
+#include <boost/proto/core.hpp>
+#include <boost/proto/transform.hpp>
+#include <boost/msm/msm_grammar.hpp>
+#include <boost/fusion/container/list/cons.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+ struct state_copy_tag
+ {
+ };
+
+template<class X = proto::is_proto_expr>
+struct define_states_creation
+{
+   BOOST_PROTO_BASIC_EXTENDS(
+       proto::terminal<state_copy_tag>::type
+     , define_states_creation
+     , boost::msm::msm_domain
+   )
+};
+
+define_states_creation<> const states_ = {{{}}};
+
+ struct FoldToList
+  : ::boost::proto::or_<
+        // Don't add the states_ terminal to the list
+        ::boost::proto::when<
+            ::boost::proto::terminal< state_copy_tag >
+          , ::boost::proto::_state
+        >
+        // Put all other terminals at the head of the
+        // list that we're building in the "state" parameter
+        // first states for the eUML states
+      , ::boost::proto::when<
+            ::boost::proto::terminal< state_tag >
+            , boost::fusion::cons< ::boost::proto::_, ::boost::proto::_state>(
+                ::boost::proto::_, ::boost::proto::_state
+            )
+        >
+        // then states from other front-ends
+      , ::boost::proto::when<
+      ::boost::proto::terminal< proto::_ >
+            , boost::fusion::cons< ::boost::proto::_value, ::boost::proto::_state>(
+                ::boost::proto::_value, ::boost::proto::_state
+    )
+        >
+        // For left-shift operations, first fold the right
+        // child to a list using the current state. Use
+        // the result as the state parameter when folding
+        // the left child to a list.
+      , ::boost::proto::when<
+            ::boost::proto::shift_left<FoldToList, FoldToList>
+          , FoldToList(
+                ::boost::proto::_left
+              , ::boost::proto::call<FoldToList( ::boost::proto::_right, ::boost::proto::_state )>
+            )
+        >
+    >
+ {};
+
+}}}
+
+#endif //BOOST_MSM_BACK_FOLD_TO_LIST_H
+

test/external/boost/msm/back/history_policies.hpp

@@ -0,0 +1,182 @@
+// 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_BACK_HISTORY_POLICIES_H
+#define BOOST_MSM_BACK_HISTORY_POLICIES_H
+
+#include <boost/mpl/contains.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+
+// policy classes
+
+// Default: no history used
+template <int NumberOfRegions>
+class NoHistoryImpl
+{
+public:
+    NoHistoryImpl(){}
+    ~NoHistoryImpl(){}
+    void set_initial_states(int* const initial_states)
+    {
+        for (int i=0;i<NumberOfRegions;++i)
+            m_initialStates[i] = initial_states[i];
+    }
+    void history_exit(int* const )
+    {
+        // ignore
+    }
+    // returns the state where the state machine should be at start
+    template <class Event>
+    const int* history_entry(Event const& )
+    {
+        // always come back to the original state
+        return m_initialStates;
+    }
+    NoHistoryImpl<NumberOfRegions>& operator=(NoHistoryImpl<NumberOfRegions> const& rhs)
+    {
+         for (int i=0; i<NumberOfRegions;++i)
+         {
+             m_initialStates[i] = rhs.m_initialStates[i];
+         }
+         return *this;
+    }
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int)
+    {
+        ar & m_initialStates;
+    }
+private:
+    int m_initialStates[NumberOfRegions];
+};
+
+// not UML standard. Always activates history, no matter which event generated the transition
+template <int NumberOfRegions>
+class AlwaysHistoryImpl
+{
+public:
+    AlwaysHistoryImpl(){}
+    ~AlwaysHistoryImpl(){}
+    void set_initial_states(int* const initial_states)
+    {
+        for (int i=0;i<NumberOfRegions;++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];
+    }
+    // returns the state where the state machine should be at start
+    template <class Event>
+    const int* history_entry(Event const& )
+    {
+        // always load back the last active state
+        return m_initialStates;
+    }
+    AlwaysHistoryImpl<NumberOfRegions>& operator=(AlwaysHistoryImpl<NumberOfRegions> const& rhs)
+    {
+         for (int i=0; i<NumberOfRegions;++i)
+         {
+             m_initialStates[i] = rhs.m_initialStates[i];
+         }
+         return *this;
+    }
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int)
+    {
+        ar & m_initialStates;
+    }
+private:
+    int m_initialStates[NumberOfRegions];
+};
+
+// UML Shallow history. For deep history, just use this policy for all the contained state machines
+template <class Events,int NumberOfRegions>
+class ShallowHistoryImpl
+{
+public:
+    ShallowHistoryImpl(){}
+    ~ShallowHistoryImpl(){}
+    void set_initial_states(int* const initial_states)
+    {
+        for (int i=0;i<NumberOfRegions;++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];
+    }
+    // returns the state where the state machine should be at start
+    template <class Event>
+    const int* history_entry(Event const&)
+    {
+        if ( ::boost::mpl::contains<Events,Event>::value)
+        {
+            return m_currentStates;
+        }
+        // not one of our events, no history
+        return m_initialStates;
+    }
+    ShallowHistoryImpl<Events,NumberOfRegions>& operator=(ShallowHistoryImpl<Events,NumberOfRegions> const& rhs)
+    {
+         for (int i=0; i<NumberOfRegions;++i)
+         {
+             m_initialStates[i] = rhs.m_initialStates[i];
+             m_currentStates[i] = rhs.m_currentStates[i];
+         }
+         return *this;
+    }
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int)
+    {
+        ar & m_initialStates;
+        ar & m_currentStates;
+    }
+private:
+    int m_initialStates[NumberOfRegions];
+    int m_currentStates[NumberOfRegions];
+};
+
+struct NoHistory
+{
+    typedef int history_policy;
+    template <int NumberOfRegions>
+    struct apply
+    {
+        typedef NoHistoryImpl<NumberOfRegions> type;
+    };
+};
+struct AlwaysHistory
+{
+    typedef int history_policy;
+    template <int NumberOfRegions>
+    struct apply
+    {
+        typedef AlwaysHistoryImpl<NumberOfRegions> type;
+    };
+};
+template <class Events>
+struct ShallowHistory
+{
+    typedef int history_policy;
+    template <int NumberOfRegions>
+    struct apply
+    {
+        typedef ShallowHistoryImpl<Events,NumberOfRegions> type;
+    };
+};
+} } }//boost::msm::back
+#endif //BOOST_MSM_BACK_HISTORY_POLICIES_H

test/external/boost/msm/back/metafunctions.hpp

@@ -0,0 +1,930 @@
+// 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_BACK_METAFUNCTIONS_H
+#define BOOST_MSM_BACK_METAFUNCTIONS_H
+
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/pair.hpp>
+#include <boost/mpl/map.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/find.hpp>
+#include <boost/mpl/count_if.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/has_key.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/next_prior.hpp>
+#include <boost/mpl/map.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/insert_range.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/logical.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/copy_if.hpp>
+#include <boost/mpl/back_inserter.hpp>
+#include <boost/mpl/transform.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/enable_if.hpp>
+
+// mpl_graph graph implementation and depth first search
+#include <boost/msm/mpl_graph/incidence_list_graph.hpp>
+#include <boost/msm/mpl_graph/depth_first_search.hpp>
+
+BOOST_MPL_HAS_XXX_TRAIT_DEF(explicit_creation)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(pseudo_entry)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(pseudo_exit)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(concrete_exit_state)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(composite_tag)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(not_real_row_tag)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(event_blocking_flag)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(explicit_entry_state)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(completion_event)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(no_exception_thrown)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(no_message_queue)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(activate_deferred_events)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(wrapped_entry)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(active_state_switch_policy)
+
+namespace boost { namespace msm { namespace back
+{
+template <typename Sequence, typename Range>
+struct set_insert_range
+{
+    typedef typename ::boost::mpl::fold<
+        Range,Sequence, 
+        ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2 >
+    >::type type;
+};
+
+// returns the current state type of a transition
+template <class Transition>
+struct transition_source_type
+{
+    typedef typename Transition::current_state_type type;
+};
+
+// returns the target state type of a transition
+template <class Transition>
+struct transition_target_type
+{
+    typedef typename Transition::next_state_type type;
+};
+
+// helper functions for generate_state_ids
+// create a pair of a state and a passed id for source and target states
+template <class Id,class Transition>
+struct make_pair_source_state_id
+{
+    typedef typename ::boost::mpl::pair<typename Transition::current_state_type,Id> type;
+};
+template <class Id,class Transition>
+struct make_pair_target_state_id
+{
+    typedef typename ::boost::mpl::pair<typename Transition::next_state_type,Id> type;
+};
+
+// iterates through a transition table and automatically generates ids starting at 0
+// first the source states, transition up to down
+// then the target states, up to down
+template <class stt>
+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>,
+                                            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>,
+                                           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;
+    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>,
+                                            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>,
+                                           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;
+    typedef typename ::boost::mpl::first<all_state_ids>::type type;
+};
+
+template <class Fsm>
+struct get_active_state_switch_policy_helper
+{
+    typedef typename Fsm::active_state_switch_policy type;
+};
+template <class Iter>
+struct get_active_state_switch_policy_helper2
+{
+    typedef typename boost::mpl::deref<Iter>::type Fsm;
+    typedef typename Fsm::active_state_switch_policy type;
+};
+// returns the active state switching policy
+template <class Fsm>
+struct get_active_state_switch_policy
+{
+    typedef typename ::boost::mpl::find_if<
+        typename Fsm::configuration,
+        has_active_state_switch_policy< ::boost::mpl::placeholders::_1 > >::type iter;
+
+    typedef typename ::boost::mpl::eval_if<
+        typename ::boost::is_same<
+            iter, 
+            typename ::boost::mpl::end<typename Fsm::configuration>::type
+        >::type,
+        get_active_state_switch_policy_helper<Fsm>,
+        get_active_state_switch_policy_helper2< iter >
+    >::type type;
+};
+
+// returns the id of a given state
+template <class stt,class State>
+struct get_state_id
+{
+    typedef typename ::boost::mpl::at<typename generate_state_ids<stt>::type,State>::type type;
+    enum {value = type::value};
+};
+
+// returns a mpl::vector containing the init states of a state machine
+template <class States>
+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;
+};
+
+// returns a mpl::int_ containing the size of a region. If the argument is not a sequence, returns 1
+template <class region>
+struct get_number_of_regions 
+{
+    typedef typename mpl::if_<
+        ::boost::mpl::is_sequence<region>,
+        ::boost::mpl::size<region>,
+        ::boost::mpl::int_<1> >::type type;
+};
+
+// builds a mpl::vector of initial states
+//TODO remove duplicate from get_initial_states
+template <class region>
+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;
+};
+
+template <class ToCreateSeq>
+struct get_explicit_creation_as_sequence 
+{
+    typedef typename ::boost::mpl::if_<
+        ::boost::mpl::is_sequence<ToCreateSeq>,
+        ToCreateSeq,
+        typename ::boost::mpl::push_back< ::boost::mpl::vector0<>,ToCreateSeq>::type >::type type;
+};
+
+// returns true if 2 transitions have the same source (used to remove duplicates in search of composite states)
+template <class stt,class Transition1,class Transition2>
+struct have_same_source
+{
+    enum {current_state1 = get_state_id<stt,typename Transition1::current_state_type >::type::value};
+    enum {current_state2 = get_state_id<stt,typename Transition2::current_state_type >::type::value};
+    enum {value = ((int)current_state1 == (int)current_state2) };
+};
+
+
+// A metafunction that returns the Event associated with a transition.
+template <class Transition>
+struct transition_event
+{
+    typedef typename Transition::transition_event type;
+};
+
+// returns true for composite states
+template <class State>
+struct is_composite_state
+{
+    enum {value = has_composite_tag<State>::type::value};
+    typedef typename has_composite_tag<State>::type type;
+};
+
+// transform a transition table in a container of source states
+template <class stt>
+struct keep_source_names
+{
+    // 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;
+};
+
+// transform a transition table in a container of target states
+template <class stt>
+struct keep_target_names
+{
+    // 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;
+};
+
+template <class stt>
+struct generate_state_set
+{
+    // keep in the original transition table only the source/target state types
+    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;
+    typedef typename 
+        ::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
+template <class stt>
+struct generate_event_set
+{
+    typedef typename 
+        ::boost::mpl::fold<
+            stt, ::boost::mpl::set<>,
+            ::boost::mpl::if_<
+                ::boost::mpl::has_key< ::boost::mpl::placeholders::_1, 
+                                       transition_event< ::boost::mpl::placeholders::_2> >,
+                ::boost::mpl::placeholders::_1,
+                ::boost::mpl::insert< ::boost::mpl::placeholders::_1,
+                                      transition_event< ::boost::mpl::placeholders::_2> > >
+        >::type type;
+};
+
+// returns a mpl::bool_<true> if State has Event as deferred event
+template <class State, class Event>
+struct has_state_delayed_event  
+{
+    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;
+};
+// returns a mpl::bool_<true> if State has any deferred event
+template <class State>
+struct has_state_delayed_events  
+{
+    typedef typename ::boost::mpl::if_<
+        ::boost::mpl::empty<typename State::deferred_events>,
+        ::boost::mpl::bool_<false>,
+        ::boost::mpl::bool_<true> >::type type;
+};
+
+// Template used to create dummy entries for initial states not found in the stt.
+template< typename T1 >
+struct not_a_row
+{
+    typedef int not_real_row_tag;
+    struct dummy_event 
+    {
+    };
+    typedef T1                  current_state_type;
+    typedef T1                  next_state_type;
+    typedef dummy_event         transition_event;
+};
+
+// metafunctions used to find out if a state is entry, exit or something else
+template <class State>
+struct is_pseudo_entry 
+{
+    typedef typename ::boost::mpl::if_< typename has_pseudo_entry<State>::type,
+        ::boost::mpl::bool_<true>,::boost::mpl::bool_<false> 
+    >::type type;
+};
+// says if a state is an exit pseudo state
+template <class State>
+struct is_pseudo_exit 
+{
+    typedef typename ::boost::mpl::if_< typename has_pseudo_exit<State>::type,
+        ::boost::mpl::bool_<true>, ::boost::mpl::bool_<false> 
+    >::type type;
+};
+// says if a state is an entry pseudo state or an explicit entry
+template <class State>
+struct is_direct_entry 
+{
+    typedef typename ::boost::mpl::if_< typename has_explicit_entry_state<State>::type,
+        ::boost::mpl::bool_<true>, ::boost::mpl::bool_<false> 
+    >::type type;
+};
+
+//converts a "fake" (simulated in a state_machine_ description )state into one which will really get created
+template <class StateType,class CompositeType>
+struct convert_fake_state
+{
+    // converts a state (explicit entry) into the state we really are going to create (explicit<>)
+    typedef typename ::boost::mpl::if_<
+        typename is_direct_entry<StateType>::type,
+        typename CompositeType::template direct<StateType>,
+        typename ::boost::mpl::identity<StateType>::type
+    >::type type;
+};
+
+template <class StateType>
+struct get_explicit_creation 
+{
+    typedef typename StateType::explicit_creation type;
+};
+
+template <class StateType>
+struct get_wrapped_entry 
+{
+    typedef typename StateType::wrapped_entry type;
+};
+// used for states created with explicit_creation
+// if the state is an explicit entry, we reach for the wrapped state
+// otherwise, this returns the state itself
+template <class StateType>
+struct get_wrapped_state 
+{
+    typedef typename ::boost::mpl::eval_if<
+                typename has_wrapped_entry<StateType>::type,
+                get_wrapped_entry<StateType>,
+                ::boost::mpl::identity<StateType> >::type type;
+};
+
+template <class Derived>
+struct create_stt 
+{
+    //typedef typename Derived::transition_table stt;
+    typedef typename Derived::real_transition_table Stt;
+    // get the state set
+    typedef typename generate_state_set<Stt>::type states;
+    // transform the initial region(s) in a sequence
+    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< ::boost::mpl::placeholders::_1>,
+                             not_a_row< get_wrapped_state< ::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<
+            typename has_explicit_creation<Derived>::type,
+            get_explicit_creation<Derived>,
+            ::boost::mpl::vector0<> >::type
+        >::type fake_explicit_created;
+
+    typedef typename 
+        ::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< get_wrapped_state< ::boost::mpl::placeholders::_2> > > 
+                  >
+        >::type type;
+};
+
+// returns the transition table of a Composite state
+template <class Composite>
+struct get_transition_table
+{
+    typedef typename create_stt<Composite>::type type;
+};
+
+// recursively builds an internal table including those of substates, sub-substates etc.
+// variant for submachines
+template <class StateType,class IsComposite>
+struct recursive_get_internal_transition_table
+{
+    // get the composite's internal table
+    typedef typename StateType::internal_transition_table composite_table;
+    // and for every substate (state of submachine), recursively get the internal transition table
+    typedef typename generate_state_set<typename StateType::stt>::type composite_states;
+    typedef typename ::boost::mpl::fold<
+            composite_states, composite_table,
+            ::boost::mpl::insert_range< ::boost::mpl::placeholders::_1, ::boost::mpl::end< ::boost::mpl::placeholders::_1>,
+             recursive_get_internal_transition_table< ::boost::mpl::placeholders::_2, is_composite_state< ::boost::mpl::placeholders::_2> >
+             >
+    >::type type;
+};
+// stop iterating on leafs (simple states)
+template <class StateType>
+struct recursive_get_internal_transition_table<StateType, ::boost::mpl::false_ >
+{
+    typedef typename StateType::internal_transition_table type;
+};
+// recursively get a transition table for a given composite state.
+// returns the transition table for this state + the tables of all composite sub states recursively
+template <class Composite>
+struct recursive_get_transition_table
+{
+    // 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;
+
+    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 > >
+    >::type type;
+
+};
+
+// metafunction used to say if a SM has pseudo exit states
+template <class Derived>
+struct has_fsm_deferred_events 
+{
+    typedef typename create_stt<Derived>::type Stt;
+    typedef typename generate_state_set<Stt>::type state_list;
+
+    typedef typename ::boost::mpl::or_<
+        typename has_activate_deferred_events<Derived>::type,
+        ::boost::mpl::bool_< ::boost::mpl::count_if<
+                typename Derived::configuration,
+                has_activate_deferred_events< ::boost::mpl::placeholders::_1 > >::value != 0> 
+    >::type found_in_fsm;
+
+    typedef typename ::boost::mpl::or_<
+            found_in_fsm,
+            ::boost::mpl::bool_< ::boost::mpl::count_if<
+                state_list,has_state_delayed_events<
+                    ::boost::mpl::placeholders::_1 > >::value != 0>
+            >::type type;
+};
+
+// returns a mpl::bool_<true> if State has any delayed event
+template <class Event>
+struct is_completion_event  
+{
+    typedef typename ::boost::mpl::if_<
+        has_completion_event<Event>,
+        ::boost::mpl::bool_<true>,
+        ::boost::mpl::bool_<false> >::type type;
+};
+// metafunction used to say if a SM has eventless transitions
+template <class Derived>
+struct has_fsm_eventless_transition 
+{
+    typedef typename create_stt<Derived>::type Stt;
+    typedef typename generate_event_set<Stt>::type event_list;
+
+    typedef ::boost::mpl::bool_< ::boost::mpl::count_if<
+        event_list,is_completion_event< ::boost::mpl::placeholders::_1 > >::value != 0> type;
+};
+template <class Derived>
+struct find_completion_events 
+{
+    typedef typename create_stt<Derived>::type Stt;
+    typedef typename generate_event_set<Stt>::type event_list;
+
+    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 >
+    >::type type;
+};
+
+template <class Transition>
+struct make_vector 
+{
+    typedef ::boost::mpl::vector<Transition> type;
+};
+template< typename Entry > 
+struct get_first_element_pair_second
+{ 
+    typedef typename ::boost::mpl::front<typename Entry::second>::type type;
+}; 
+
+ //returns the owner of an explicit_entry state
+ //which is the containing SM if the transition originates from outside the containing SM
+ //or else the explicit_entry state itself
+template <class State,class ContainingSM>
+struct get_owner 
+{
+    typedef typename ::boost::mpl::if_<
+        typename ::boost::mpl::not_<typename ::boost::is_same<typename State::owner,
+                                                              ContainingSM >::type>::type,
+        typename State::owner, 
+        State >::type type;
+};
+
+template <class Sequence,class ContainingSM>
+struct get_fork_owner 
+{
+    typedef typename ::boost::mpl::front<Sequence>::type seq_front;
+    typedef typename ::boost::mpl::if_<
+                    typename ::boost::mpl::not_<
+                        typename ::boost::is_same<typename seq_front::owner,ContainingSM>::type>::type,
+                    typename seq_front::owner, 
+                    seq_front >::type type;
+};
+
+template <class StateType,class ContainingSM>
+struct make_exit 
+{
+    typedef typename ::boost::mpl::if_<
+             typename is_pseudo_exit<StateType>::type ,
+             typename ContainingSM::template exit_pt<StateType>,
+             typename ::boost::mpl::identity<StateType>::type
+            >::type type;
+};
+
+template <class StateType,class ContainingSM>
+struct make_entry 
+{
+    typedef typename ::boost::mpl::if_<
+        typename is_pseudo_entry<StateType>::type ,
+        typename ContainingSM::template entry_pt<StateType>,
+        typename ::boost::mpl::if_<
+                typename is_direct_entry<StateType>::type,
+                typename ContainingSM::template direct<StateType>,
+                typename ::boost::mpl::identity<StateType>::type
+                >::type
+        >::type type;
+};
+// metafunction used to say if a SM has pseudo exit states
+template <class StateType>
+struct has_exit_pseudo_states_helper 
+{
+    typedef typename StateType::stt Stt;
+    typedef typename generate_state_set<Stt>::type state_list;
+
+    typedef ::boost::mpl::bool_< ::boost::mpl::count_if<
+                state_list,is_pseudo_exit< ::boost::mpl::placeholders::_1> >::value != 0> type;
+};
+template <class StateType>
+struct has_exit_pseudo_states 
+{
+    typedef typename ::boost::mpl::eval_if<typename is_composite_state<StateType>::type,
+        has_exit_pseudo_states_helper<StateType>,
+        ::boost::mpl::bool_<false> >::type type;
+};
+
+template <class StateType>
+struct is_state_blocking 
+{
+    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 >
+    >::type blocking_flags;
+
+    typedef typename ::boost::mpl::if_<
+        ::boost::mpl::empty<blocking_flags>,
+        ::boost::mpl::bool_<false>,
+        ::boost::mpl::bool_<true> >::type type;
+};
+// returns a mpl::bool_<true> if fsm has an event blocking flag in one of its substates
+template <class StateType>
+struct has_fsm_blocking_states  
+{
+    typedef typename create_stt<StateType>::type Stt;
+    typedef typename generate_state_set<Stt>::type state_list;
+
+    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 >
+    >::type blocking_states;
+
+    typedef typename ::boost::mpl::if_<
+        ::boost::mpl::empty<blocking_states>,
+        ::boost::mpl::bool_<false>,
+        ::boost::mpl::bool_<true> >::type type;
+};
+
+template <class StateType>
+struct is_no_exception_thrown
+{
+    typedef ::boost::mpl::bool_< ::boost::mpl::count_if<
+        typename StateType::configuration,
+        has_no_exception_thrown< ::boost::mpl::placeholders::_1 > >::value != 0> found;
+
+    typedef typename ::boost::mpl::or_<
+        typename has_no_exception_thrown<StateType>::type,
+        found
+    >::type type;
+};
+
+template <class StateType>
+struct is_no_message_queue
+{
+    typedef ::boost::mpl::bool_< ::boost::mpl::count_if<
+        typename StateType::configuration,
+        has_no_message_queue< ::boost::mpl::placeholders::_1 > >::value != 0> found;
+
+    typedef typename ::boost::mpl::or_<
+        typename has_no_message_queue<StateType>::type,
+        found
+    >::type type;
+};
+
+template <class StateType>
+struct is_active_state_switch_policy 
+{
+    typedef ::boost::mpl::bool_< ::boost::mpl::count_if<
+        typename StateType::configuration,
+        has_active_state_switch_policy< ::boost::mpl::placeholders::_1 > >::value != 0> found;
+
+    typedef typename ::boost::mpl::or_<
+        typename has_active_state_switch_policy<StateType>::type,
+        found
+    >::type type;
+};
+
+template <class StateType>
+struct get_initial_event 
+{
+    typedef typename StateType::initial_event type;
+};
+
+template <class StateType>
+struct get_final_event 
+{
+    typedef typename StateType::final_event type;
+};
+
+template <class TransitionTable, class InitState>
+struct build_one_orthogonal_region 
+{
+     template<typename Row>
+     struct row_to_incidence :
+         ::boost::mpl::vector<
+                ::boost::mpl::pair<
+                    typename Row::next_state_type, 
+                    typename Row::transition_event>, 
+                typename Row::current_state_type, 
+                typename Row::next_state_type
+         > {};
+
+     template <class Seq, class Elt>
+     struct transition_incidence_list_helper 
+     {
+         typedef typename ::boost::mpl::push_back< Seq, row_to_incidence< Elt > >::type type;
+     };
+
+     typedef typename ::boost::mpl::fold<
+         TransitionTable,
+         ::boost::mpl::vector<>,
+         transition_incidence_list_helper< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2>
+     >::type transition_incidence_list;
+
+     typedef ::boost::msm::mpl_graph::incidence_list_graph<transition_incidence_list>
+         transition_graph;
+
+     struct preordering_dfs_visitor : 
+         ::boost::msm::mpl_graph::dfs_default_visitor_operations 
+     {    
+         template<typename Node, typename Graph, typename State>
+         struct discover_vertex :
+             ::boost::mpl::insert<State, Node>
+         {};
+     };
+
+     typedef typename mpl::first< 
+         typename ::boost::msm::mpl_graph::depth_first_search<
+            transition_graph, 
+            preordering_dfs_visitor,
+            ::boost::mpl::set<>,
+            InitState
+         >::type
+     >::type type;
+};
+
+template <class Fsm>
+struct find_entry_states 
+{
+    typedef typename ::boost::mpl::copy<
+        typename Fsm::substate_list,
+        ::boost::mpl::inserter< 
+            ::boost::mpl::set0<>,
+            ::boost::mpl::if_<
+                has_explicit_entry_state< ::boost::mpl::placeholders::_2 >,
+                ::boost::mpl::insert< ::boost::mpl::placeholders::_1, ::boost::mpl::placeholders::_2>,
+                ::boost::mpl::placeholders::_1
+            >
+        >
+    >::type type;
+};
+
+template <class Set1, class Set2>
+struct is_common_element 
+{
+    typedef typename ::boost::mpl::fold<
+        Set1, ::boost::mpl::false_,
+        ::boost::mpl::if_<
+            ::boost::mpl::has_key<
+                Set2,
+                ::boost::mpl::placeholders::_2
+            >,
+            ::boost::mpl::true_,
+            ::boost::mpl::placeholders::_1
+        >
+    >::type type;
+};
+
+template <class EntryRegion, class AllRegions>
+struct add_entry_region 
+{
+    typedef typename ::boost::mpl::transform<
+        AllRegions, 
+        ::boost::mpl::if_<
+            is_common_element<EntryRegion, ::boost::mpl::placeholders::_1>,
+            set_insert_range< ::boost::mpl::placeholders::_1, EntryRegion>,
+            ::boost::mpl::placeholders::_1
+        >
+    >::type type;
+};
+
+// build a vector of regions states (as a set)
+// one set of states for every region
+template <class Fsm, class InitStates>
+struct build_orthogonal_regions 
+{
+    typedef typename 
+        ::boost::mpl::fold<
+            InitStates, ::boost::mpl::vector0<>,
+            ::boost::mpl::push_back< 
+                ::boost::mpl::placeholders::_1, 
+                build_one_orthogonal_region< typename Fsm::stt, ::boost::mpl::placeholders::_2 > >
+        >::type without_entries;
+
+    typedef typename 
+        ::boost::mpl::fold<
+        typename find_entry_states<Fsm>::type, ::boost::mpl::vector0<>,
+            ::boost::mpl::push_back< 
+                ::boost::mpl::placeholders::_1, 
+                build_one_orthogonal_region< typename Fsm::stt, ::boost::mpl::placeholders::_2 > >
+        >::type only_entries;
+
+    typedef typename ::boost::mpl::fold<
+        only_entries , without_entries,
+        add_entry_region< ::boost::mpl::placeholders::_2, ::boost::mpl::placeholders::_1>
+    >::type type;
+};
+
+template <class GraphAsSeqOfSets, class StateType>
+struct find_region_index
+{
+    typedef typename 
+        ::boost::mpl::fold<
+            GraphAsSeqOfSets, ::boost::mpl::pair< ::boost::mpl::int_< -1 > /*res*/, ::boost::mpl::int_<0> /*counter*/ >,
+            ::boost::mpl::if_<
+                ::boost::mpl::has_key< ::boost::mpl::placeholders::_2, StateType >,
+                ::boost::mpl::pair< 
+                    ::boost::mpl::second< ::boost::mpl::placeholders::_1 >,
+                    ::boost::mpl::next< ::boost::mpl::second< ::boost::mpl::placeholders::_1 > >
+                >,
+                ::boost::mpl::pair< 
+                    ::boost::mpl::first< ::boost::mpl::placeholders::_1 >,
+                    ::boost::mpl::next< ::boost::mpl::second< ::boost::mpl::placeholders::_1 > >
+                >
+            >
+        >::type result_pair;
+    typedef typename ::boost::mpl::first<result_pair>::type type;
+    enum {value = type::value};
+};
+
+template <class Fsm>
+struct check_regions_orthogonality
+{
+    typedef typename build_orthogonal_regions< Fsm,typename Fsm::initial_states>::type regions;
+    
+    typedef typename ::boost::mpl::fold<
+        regions, ::boost::mpl::int_<0>,
+        ::boost::mpl::plus< ::boost::mpl::placeholders::_1 , ::boost::mpl::size< ::boost::mpl::placeholders::_2> >
+    >::type number_of_states_in_regions;
+
+    typedef typename ::boost::mpl::fold<
+            regions,mpl::set0<>,
+            set_insert_range< 
+                    ::boost::mpl::placeholders::_1, 
+                    ::boost::mpl::placeholders::_2 > 
+    >::type one_big_states_set;
+
+    enum {states_in_regions_raw = number_of_states_in_regions::value};
+    enum {cumulated_states_in_regions_raw = ::boost::mpl::size<one_big_states_set>::value};
+};
+
+template <class Fsm>
+struct check_no_unreachable_state
+{
+    typedef typename check_regions_orthogonality<Fsm>::one_big_states_set states_in_regions;
+
+    typedef typename set_insert_range<
+        states_in_regions, 
+        typename ::boost::mpl::eval_if<
+            typename has_explicit_creation<Fsm>::type,
+            get_explicit_creation<Fsm>,
+            ::boost::mpl::vector0<>
+        >::type
+    >::type with_explicit_creation;
+
+    enum {states_in_fsm = ::boost::mpl::size< typename Fsm::substate_list >::value};
+    enum {cumulated_states_in_regions = ::boost::mpl::size< with_explicit_creation >::value};
+};
+
+// helper to find out if a SM has an active exit state and is therefore waiting for exiting
+template <class StateType,class OwnerFct,class FSM>
+inline
+typename ::boost::enable_if<typename ::boost::mpl::and_<typename is_composite_state<FSM>::type,
+                                                        typename is_pseudo_exit<StateType>::type>,bool >::type
+is_exit_state_active(FSM& fsm)
+{
+    typedef typename OwnerFct::type Composite;
+    //typedef typename create_stt<Composite>::type stt;
+    typedef typename Composite::stt stt;
+    int state_id = get_state_id<stt,StateType>::type::value;
+    Composite& comp = fsm.template get_state<Composite&>();
+    return (std::find(comp.current_state(),comp.current_state()+Composite::nr_regions::value,state_id)
+                            !=comp.current_state()+Composite::nr_regions::value);
+}
+template <class StateType,class OwnerFct,class FSM>
+inline
+typename ::boost::disable_if<typename ::boost::mpl::and_<typename is_composite_state<FSM>::type,
+                                                         typename is_pseudo_exit<StateType>::type>,bool >::type
+is_exit_state_active(FSM&)
+{
+    return false;
+}
+
+} } }//boost::msm::back
+
+#endif // BOOST_MSM_BACK_METAFUNCTIONS_H
+

test/external/boost/msm/back/mpl_graph_fsm_check.hpp

@@ -0,0 +1,48 @@
+// 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_BACK_MPL_GRAPH_FSM_CHECK_H
+#define BOOST_MSM_BACK_MPL_GRAPH_FSM_CHECK_H
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/msm/back/metafunctions.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+    struct mpl_graph_fsm_check
+    {
+        typedef int fsm_check;
+        // checks that regions are truly orthogonal (one state belongs to 1 region)
+        // using the mpl_graph library (part of metagraph)
+        template <class Fsm>
+        static void check_orthogonality()
+        {
+            BOOST_MPL_ASSERT_RELATION( ::boost::msm::back::check_regions_orthogonality<Fsm>::states_in_regions_raw,
+                                       ==, 
+                                       ::boost::msm::back::check_regions_orthogonality<Fsm>::cumulated_states_in_regions_raw );
+
+        }
+        // checks that all states are reachable or created using the explicit_creation typedef
+        // using the mpl_graph library (part of metagraph)
+        template <class Fsm>
+        static void check_unreachable_states()
+        {
+            BOOST_MPL_ASSERT_RELATION( ::boost::msm::back::check_no_unreachable_state<Fsm>::states_in_fsm,
+                                       ==, 
+                                       ::boost::msm::back::check_no_unreachable_state<Fsm>::cumulated_states_in_regions );
+
+        }
+    };
+
+} } }//boost::msm::back
+
+
+#endif //BOOST_MSM_BACK_MPL_GRAPH_FSM_CHECK_H

test/external/boost/msm/back/no_fsm_check.hpp

@@ -0,0 +1,37 @@
+// 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_BACK_NO_FSM_CHECK_H
+#define BOOST_MSM_BACK_NO_FSM_CHECK_H
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/msm/back/metafunctions.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+    struct no_fsm_check
+    {
+        typedef int fsm_check;
+        // no fsm structure checking
+        template <class Fsm>
+        static void check_orthogonality()
+        {
+        }
+        template <class Fsm>
+        static void check_unreachable_states()
+        {
+        }
+    };
+
+} } }//boost::msm::back
+
+
+#endif //BOOST_MSM_BACK_NO_FSM_CHECK_H

test/external/boost/msm/back/queue_container_circular.hpp

@@ -0,0 +1,32 @@
+// 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_BACK_QUEUE_CONTAINER_CIRCULAR_H
+#define BOOST_MSM_BACK_QUEUE_CONTAINER_CIRCULAR_H
+
+#include <boost/circular_buffer.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+    struct queue_container_circular
+    {
+        typedef int queue_container_policy;
+
+        template <class Element>
+        struct In 
+        {
+            typedef typename boost::circular_buffer<Element> type;
+        };
+    };
+
+} } }//boost::msm::back
+
+
+#endif //BOOST_MSM_BACK_QUEUE_CONTAINER_CIRCULAR_H

test/external/boost/msm/back/queue_container_deque.hpp

@@ -0,0 +1,32 @@
+// 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_BACK_QUEUE_CONTAINER_DEQUE_H
+#define BOOST_MSM_BACK_QUEUE_CONTAINER_DEQUE_H
+
+#include <deque>
+
+namespace boost { namespace msm { namespace back
+{
+    struct queue_container_deque
+    {
+        typedef int queue_container_policy;
+
+        template <class Element>
+        struct In 
+        {
+            typedef typename std::deque<Element> type;
+        };
+    };
+
+} } }//boost::msm::back
+
+
+#endif //BOOST_MSM_BACK_QUEUE_CONTAINER_DEQUE_H

test/external/boost/msm/back/tools.hpp

@@ -0,0 +1,68 @@
+// 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_BACK_TOOLS_H
+#define BOOST_MSM_BACK_TOOLS_H
+
+
+#include <string>
+#include <iostream>
+#include <boost/msm/back/common_types.hpp>
+#include <boost/msm/back/metafunctions.hpp>
+
+namespace boost { namespace msm { namespace back
+{
+
+// fills the array passed in with the state names in the correct order
+// the array must be big enough. To know the needed size, use mpl::size
+// on fsm::generate_state_set
+template <class stt>
+struct fill_state_names
+{
+    fill_state_names(char const** names):m_names(names){}
+    template <class StateType>
+    void operator()(boost::msm::wrap<StateType> const&)
+    {
+        m_names[get_state_id<stt,StateType>::value]= typeid(StateType).name();
+    }
+private:
+    char const** m_names;
+};
+
+// fills the typeid-generated name of the given state in the string passed as argument
+template <class stt>
+struct get_state_name
+{
+    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::wrap<StateType> const&)
+    {
+        if (get_state_id<stt,StateType>::value == m_state_id)
+        {
+            m_name = typeid(StateType).name();
+        }
+    }
+private:
+    std::string&    m_name;
+    int             m_state_id;
+};
+
+// displays the typeid of the given Type
+struct display_type 
+{
+    template <class Type>
+    void operator()(boost::msm::wrap<Type> const&)
+    {
+        std::cout << typeid(Type).name() << std::endl;
+    }
+};
+
+} } }//boost::msm::back
+#endif //BOOST_MSM_BACK_TOOLS_H

test/external/boost/msm/common.hpp

@@ -0,0 +1,27 @@
+// 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{};
+
+// tag to use in grammars where states are seen (init_<<, states_<<...)
+struct state_tag{};
+
+} } // boost::msm
+#endif //BOOST_MSM_COMMON_H
+

test/external/boost/msm/front/common_states.hpp

@@ -0,0 +1,37 @@
+// 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_FRONT_COMMON_STATES_H
+#define BOOST_MSM_FRONT_COMMON_STATES_H
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/fusion/container/map.hpp>
+#include <boost/fusion/include/at_c.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/msm/front/detail/common_states.hpp>
+
+namespace boost { namespace msm { namespace front
+{
+// default base: non-polymorphic, not visitable
+struct default_base_state 
+{
+    ~default_base_state(){}
+};
+// default polymorphic base state. Derive all states from it to get polymorphic behavior
+struct polymorphic_state
+{
+    virtual ~polymorphic_state() {}
+};
+
+}}}
+
+#endif //BOOST_MSM_FRONT_COMMON_STATES_H
+

test/external/boost/msm/front/completion_event.hpp

@@ -0,0 +1,31 @@
+// 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_FRONT_COMMON_COMPLETION_EVENT_H
+#define BOOST_MSM_FRONT_COMMON_COMPLETION_EVENT_H
+
+namespace boost { namespace msm { namespace front
+{
+
+    struct none
+    {
+        // make every event convertible to none.
+        // to support standard-conform implementation of pseudo exits.
+        none(){}
+        template <class Event>
+        none(Event const&){}
+
+        typedef int completion_event;
+    };
+
+}}}
+
+#endif //BOOST_MSM_FRONT_COMMON_COMPLETION_EVENT_H
+

test/external/boost/msm/front/detail/common_states.hpp

@@ -0,0 +1,77 @@
+// 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_FRONT_DETAILS_COMMON_STATES_H
+#define BOOST_MSM_FRONT_DETAILS_COMMON_STATES_H
+
+#include <boost/mpl/int.hpp>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/fusion/container/map.hpp>
+#include <boost/fusion/include/at_key.hpp>
+#include <boost/type_traits/add_const.hpp>
+
+namespace boost { namespace msm { namespace front {namespace detail
+{
+template <class Attributes= ::boost::fusion::map<> >
+struct inherit_attributes
+{
+    inherit_attributes():m_attributes(){}
+    inherit_attributes(Attributes const& the_attributes):m_attributes(the_attributes){}
+    // on the fly attribute creation capability
+    typedef Attributes      attributes_type;
+    template <class Index>
+    typename ::boost::fusion::result_of::at_key<attributes_type, 
+                                                Index>::type
+    get_attribute(Index const&) 
+    {
+        return ::boost::fusion::at_key<Index>(m_attributes);
+    }
+    
+    template <class Index>
+    typename ::boost::add_const<
+        typename ::boost::fusion::result_of::at_key<attributes_type,
+                                                    Index>::type>::type
+    get_attribute(Index const&)const 
+    {
+        return const_cast< 
+            typename ::boost::add_const< 
+                typename ::boost::fusion::result_of::at_key< attributes_type,
+                                                             Index >::type>::type>
+                                (::boost::fusion::at_key<Index>(m_attributes));
+    }
+
+private:
+    // 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;
+
+    // empty implementation for the states not wishing to define an entry condition
+    // will not be called polymorphic way
+    template <class Event,class FSM>
+    void on_entry(Event const& ,FSM&){}
+    template <class Event,class FSM>
+    void on_exit(Event const&,FSM& ){}
+    // default (empty) transition table;
+    typedef ::boost::mpl::vector0<>  internal_transition_table;
+    typedef ::boost::mpl::vector0<>  transition_table;
+};
+
+}}}}
+
+#endif //BOOST_MSM_FRONT_DETAILS_COMMON_STATES_H
+

test/external/boost/msm/front/detail/row2_helper.hpp

@@ -0,0 +1,71 @@
+// 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_ROW2_HELPER_HPP
+#define BOOST_MSM_ROW2_HELPER_HPP
+
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/include/at_key.hpp>
+
+namespace boost { namespace msm { namespace front
+{
+    namespace detail
+    {
+        template<
+            typename CalledForAction
+            , typename Event
+            , void (CalledForAction::*action)(Event const&)
+        >
+        struct row2_action_helper
+        {
+            template <class FSM,class Evt,class SourceState,class TargetState, class AllStates>
+            static void call_helper(FSM&,Evt const& evt,SourceState&,TargetState&,
+                                    AllStates& all_states,::boost::mpl::false_ const &)
+            {
+                // in this front-end, we don't need to know source and target states
+                ( ::boost::fusion::at_key<CalledForAction>(all_states).*action)(evt);
+            }
+            template <class FSM,class Evt,class SourceState,class TargetState, class AllStates>
+            static void call_helper(FSM& fsm,Evt const& evt,SourceState&,TargetState&,AllStates&,
+                                    ::boost::mpl::true_ const &)
+            {
+                // in this front-end, we don't need to know source and target states
+                (fsm.*action)(evt);
+            }
+        };
+
+        template<
+            typename CalledForGuard
+            , typename Event
+            , bool (CalledForGuard::*guard)(Event const&)
+        >
+        struct row2_guard_helper
+        {
+            template <class FSM,class Evt,class SourceState,class TargetState,class AllStates>
+            static bool call_helper(FSM&,Evt const& evt,SourceState&,TargetState&,
+                                    AllStates& all_states, ::boost::mpl::false_ const &)
+            {
+                // in this front-end, we don't need to know source and target states
+                return ( ::boost::fusion::at_key<CalledForGuard>(all_states).*guard)(evt);
+            }
+            template <class FSM,class Evt,class SourceState,class TargetState,class AllStates>
+            static bool call_helper(FSM& fsm,Evt const& evt,SourceState&,TargetState&,
+                                    AllStates&,::boost::mpl::true_ const &)
+            {
+                // in this front-end, we don't need to know source and target states
+                return (fsm.*guard)(evt);
+            }
+        };
+    }
+
+}}}
+
+#endif //BOOST_MSM_ROW2_HELPER_HPP
+

test/external/boost/msm/front/euml/algorithm.hpp

@@ -0,0 +1,19 @@
+// 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_FRONT_EUML_ALGORITHM_H
+#define BOOST_MSM_FRONT_EUML_ALGORITHM_H
+
+#include <boost/msm/front/euml/iteration.hpp>
+#include <boost/msm/front/euml/querying.hpp>
+#include <boost/msm/front/euml/transformation.hpp>
+
+
+#endif //BOOST_MSM_FRONT_EUML_ALGORITHM_H

test/external/boost/msm/front/euml/euml.hpp

@@ -0,0 +1,23 @@
+// 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_FRONT_EUML_EUML_H
+#define BOOST_MSM_FRONT_EUML_EUML_H
+
+#include <boost/msm/front/euml/common.hpp>
+#include <boost/msm/front/euml/operator.hpp>
+#include <boost/msm/front/euml/guard_grammar.hpp>
+#include <boost/msm/front/euml/state_grammar.hpp>
+#include <boost/msm/front/euml/stt_grammar.hpp>
+#ifdef BOOST_MSM_EUML_PHOENIX_SUPPORT
+#include <boost/msm/front/euml/phoenix_placeholders.hpp>
+#endif
+
+#endif //BOOST_MSM_FRONT_EUML_EUML_H

test/external/boost/msm/front/euml/euml_typeof.hpp

@@ -0,0 +1,121 @@
+// 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_FRONT_EUML_TYPEOF_H
+#define BOOST_MSM_FRONT_EUML_TYPEOF_H
+
+#include <boost/typeof/typeof.hpp>
+
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(::boost::mpl::vector0, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(::boost::mpl::vector50, 50)
+BOOST_TYPEOF_REGISTER_TYPE(::boost::mpl::na)
+BOOST_TYPEOF_REGISTER_TEMPLATE(::boost::fusion::vector, 10)
+BOOST_TYPEOF_REGISTER_TYPE(::boost::fusion::void_)
+BOOST_TYPEOF_REGISTER_TEMPLATE(::boost::mpl::vector, 20)
+BOOST_TYPEOF_REGISTER_TYPE(std::string)
+BOOST_TYPEOF_REGISTER_TEMPLATE(::boost::mpl::size_t, (unsigned int))
+
+BOOST_TYPEOF_REGISTER_TYPE(::boost::msm::front::default_base_state)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::detail::inherit_attributes, 1)
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::func_state, 6)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::entry_func_state, (int)(typename)(typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::explicit_entry_func_state, (int)(typename)(typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::exit_func_state, 7)
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::define_flag, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::attribute, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::define_defer, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::define_init, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Source_, (int))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Target_, (int))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Current_, (int))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Event_, (int))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::State_Attribute_, (typename)(int))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::State_Machine_, (int))
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::none)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::Row, 5)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::ActionSequence_, 1)
+
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::NoAction)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::And_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Or_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Not_, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::If_Else_, 3)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::If)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::If_Then_, 2)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::If_Then)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::While_Do_, 2)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::While_)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Do_While_, 2)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Do_While_)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::For_Loop_, 4)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::For_Loop_)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Process_, 1)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Process_)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Process2_, 2)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Process2_)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Get_Flag_, 1)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Get_Flag_)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Begin_, 1)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Begin_Helper)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::End_, 1)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::End_Helper)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Deref_, 1)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Deref_Helper)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Push_Back_, 2)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Push_Back_Helper)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Clear_, 1)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Clear_Helper)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Empty_, 1)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Empty_Helper)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Find_, 2)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Find_Helper)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Npos_, 1)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::False_)
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::True_)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Int_, (int))
+BOOST_TYPEOF_REGISTER_TYPE(boost::msm::front::euml::Int)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Pre_inc_, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Pre_dec_, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Post_inc_, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Post_dec_, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Plus_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Minus_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Multiplies_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Divides_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Modulus_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Bitwise_And_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Bitwise_Or_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Bitwise_Xor_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Subscript_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Plus_Assign_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Minus_Assign_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Multiplies_Assign_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Divides_Assign_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Modulus_Assign_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::ShiftLeft_Assign_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::ShiftRight_Assign_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::ShiftLeft_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::ShiftRight_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Assign_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Unary_Plus_, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Unary_Minus_, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Less_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::LessEqual_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::Greater_, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::msm::front::euml::GreaterEqual_, 2)
+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

test/external/boost/msm/front/euml/guard_grammar.hpp

@@ -0,0 +1,356 @@
+// 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_FRONT_EUML_GUARD_GRAMMAR_H
+#define BOOST_MSM_FRONT_EUML_GUARD_GRAMMAR_H
+
+#include <boost/msm/front/euml/common.hpp>
+#include <boost/msm/front/euml/operator.hpp>
+#include <boost/msm/front/euml/state_grammar.hpp>
+
+namespace boost { namespace msm { namespace front { namespace euml
+{
+struct BuildGuards;
+struct BuildActions;
+
+struct BuildGuardsCases
+{
+    // The primary template matches nothing:
+    template<typename Tag>
+    struct case_
+        : proto::not_<proto::_>
+    {};
+};
+template<>
+struct BuildGuardsCases::case_<proto::tag::logical_or>
+    : 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::logical_and<BuildGuards,BuildGuards >,
+                    And_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::logical_not>
+    : proto::when<
+                    proto::logical_not<BuildGuards >,
+                    Not_<BuildGuards(proto::_child)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::less>
+    : proto::when<
+                    proto::less<BuildGuards, BuildGuards >,
+                    Less_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::less_equal>
+    : proto::when<
+                    proto::less_equal<BuildGuards, BuildGuards >,
+                    LessEqual_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::greater>
+    : proto::when<
+                    proto::greater<BuildGuards, BuildGuards >,
+                    Greater_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::greater_equal>
+    : 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)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::not_equal_to>
+    : 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::pre_inc<BuildGuards >,
+                    Pre_inc_<BuildGuards(proto::_child)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::dereference>
+    : proto::when<
+                    proto::dereference<BuildGuards >,
+                    Deref_<BuildGuards(proto::_child)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::pre_dec>
+    : proto::when<
+                    proto::pre_dec<BuildGuards >,
+                    Pre_dec_<BuildGuards(proto::_child)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::post_inc>
+    : proto::when<
+                    proto::post_inc<BuildGuards >,
+                    Post_inc_<BuildGuards(proto::_child)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::post_dec>
+    : proto::when<
+                    proto::post_dec<BuildGuards >,
+                    Post_dec_<BuildGuards(proto::_child)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::plus>
+    : proto::when<
+                    proto::plus<BuildGuards,BuildGuards >,
+                    Plus_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::minus>
+    : proto::when<
+                    proto::minus<BuildGuards,BuildGuards >,
+                    Minus_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::multiplies>
+    : proto::when<
+                    proto::multiplies<BuildGuards,BuildGuards >,
+                    Multiplies_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::divides>
+    : proto::when<
+                    proto::divides<BuildGuards,BuildGuards >,
+                    Divides_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::modulus>
+    : proto::when<
+                    proto::modulus<BuildGuards,BuildGuards >,
+                    Modulus_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::bitwise_and>
+    : 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::bitwise_or<BuildGuards,BuildGuards >,
+                    Bitwise_Or_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::subscript>
+    : proto::when<
+                    proto::subscript<BuildGuards,BuildGuards >,
+                    Subscript_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::plus_assign>
+    : 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::minus_assign<BuildGuards,BuildGuards >,
+                    Minus_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::multiplies_assign>
+    : 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::divides_assign<BuildGuards,BuildGuards >,
+                    Divides_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::modulus_assign>
+    : 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::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::shift_right_assign<BuildGuards,BuildGuards >,
+                    ShiftRight_Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::shift_left>
+    : 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::shift_right<BuildGuards,BuildGuards >,
+                    ShiftRight_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::assign>
+    : proto::when<
+                    proto::assign<BuildGuards,BuildGuards >,
+                    Assign_<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
+                >
+{};
+template<>
+struct BuildGuardsCases::case_<proto::tag::bitwise_xor>
+    : 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::negate<BuildGuards >,
+                    Unary_Minus_<BuildGuards(proto::_child)>()
+                >
+{};
+
+template<>
+struct BuildGuardsCases::case_<proto::tag::function>
+    : 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>) >()
+                    >,
+            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::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 >,
+                    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>),BuildActions(proto::_child_c<6>) >()
+                    >
+#endif
+    >
+{};
+
+template<>
+struct BuildGuardsCases::case_<proto::tag::terminal>
+    : proto::or_<
+        proto::when <
+            proto::terminal<action_tag>,
+            get_action_name<proto::_ >()
+            >,
+        proto::when<
+            proto::terminal<state_tag>,
+            get_state_name<proto::_>()
+            >,
+        proto::when<
+            proto::terminal<flag_tag>,
+            proto::_
+            >,
+        proto::when<
+            proto::terminal<event_tag>,
+            proto::_
+            >,
+        proto::when<
+            proto::terminal<fsm_artefact_tag>,
+            get_fct<proto::_ >()
+            >,
+        proto::when<
+            proto::terminal<proto::_>,
+            proto::_value
+            >
+    >
+{};
+
+struct BuildGuards
+    : proto::switch_<BuildGuardsCases>
+{};
+
+}}}}
+
+#endif //BOOST_MSM_FRONT_EUML_GUARD_GRAMMAR_H

test/external/boost/msm/front/euml/iteration.hpp

@@ -0,0 +1,26 @@
+// 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_FRONT_EUML_ITERATION_H
+#define BOOST_MSM_FRONT_EUML_ITERATION_H
+
+#include <algorithm>
+#include <numeric>
+#include <boost/msm/front/euml/common.hpp>
+
+namespace boost { namespace msm { namespace front { namespace euml
+{
+
+BOOST_MSM_EUML_FUNCTION(ForEach_ , std::for_each , for_each_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(Accumulate_ , std::accumulate , accumulate_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+
+}}}}
+
+#endif //BOOST_MSM_FRONT_EUML_ITERATION_H

test/external/boost/msm/front/euml/phoenix_placeholders.hpp

@@ -0,0 +1,26 @@
+// Copyright 2011 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_FRONT_EUML_PHOENIX_PLACEHOLDERS_H
+#define BOOST_MSM_FRONT_EUML_PHOENIX_PLACEHOLDERS_H
+
+#include <boost/phoenix/core/argument.hpp>
+// provide some meaningful placeholders (instead of arg1...arg4)
+namespace boost { namespace msm { namespace front { namespace euml
+{
+    boost::phoenix::expression::argument<1>::type const _event = {};
+    boost::phoenix::expression::argument<2>::type const _fsm = {};
+    boost::phoenix::expression::argument<3>::type const _source = {};
+    boost::phoenix::expression::argument<4>::type const _target = {};
+    // this is for state actions
+    boost::phoenix::expression::argument<3>::type const _state = {};
+}}}}
+
+#endif //BOOST_MSM_FRONT_EUML_PHOENIX_PLACEHOLDERS_H

test/external/boost/msm/front/euml/querying.hpp

@@ -0,0 +1,43 @@
+// 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_FRONT_EUML_QUERYING_H
+#define BOOST_MSM_FRONT_EUML_QUERYING_H
+
+#include <algorithm>
+#include <boost/msm/front/euml/common.hpp>
+
+namespace boost { namespace msm { namespace front { namespace euml
+{
+
+BOOST_MSM_EUML_FUNCTION(Find_ , std::find , find_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(FindIf_ , std::find_if , find_if_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(LowerBound_ , std::lower_bound , lower_bound_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(UpperBound_ , std::upper_bound , upper_bound_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(BinarySearch_ , std::binary_search , binary_search_ , bool , bool )
+BOOST_MSM_EUML_FUNCTION(MinElement_ , std::min_element , min_element_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(MaxElement_ , std::max_element , max_element_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(AdjacentFind_ , std::adjacent_find , adjacent_find_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(FindEnd_ , std::find_end , find_end_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(FindFirstOf_ , std::find_first_of , find_first_of_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(Equal_ , std::equal , equal_ , bool , bool )
+BOOST_MSM_EUML_FUNCTION(Search_ , std::search , search_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(Includes_ , std::includes , includes_ , bool , bool )
+BOOST_MSM_EUML_FUNCTION(LexicographicalCompare_ , std::lexicographical_compare , lexicographical_compare_ , bool , bool )
+BOOST_MSM_EUML_FUNCTION(Count_ , std::count , count_ , RESULT_TYPE_DIFF_TYPE_ITER_TRAITS_PARAM1 , RESULT_TYPE2_DIFF_TYPE_ITER_TRAITS_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(CountIf_ , std::count_if , count_if_ , RESULT_TYPE_DIFF_TYPE_ITER_TRAITS_PARAM1 , RESULT_TYPE2_DIFF_TYPE_ITER_TRAITS_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(Distance_ , std::distance , distance_ , RESULT_TYPE_DIFF_TYPE_ITER_TRAITS_PARAM1 , RESULT_TYPE2_DIFF_TYPE_ITER_TRAITS_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(EqualRange_ , std::equal_range , equal_range_ , RESULT_TYPE_PAIR_REMOVE_REF_PARAM1 , RESULT_TYPE2_PAIR_REMOVE_REF_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(Mismatch_ , std::mismatch , mismatch_ , RESULT_TYPE_PAIR_REMOVE_REF_PARAM1 , RESULT_TYPE2_PAIR_REMOVE_REF_PARAM1 )
+
+
+}}}}
+
+#endif //BOOST_MSM_FRONT_EUML_QUERYING_H

test/external/boost/msm/front/euml/stl.hpp

@@ -0,0 +1,17 @@
+// 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_FRONT_EUML_STL_H
+#define BOOST_MSM_FRONT_EUML_STL_H
+
+#include <boost/msm/front/euml/container.hpp>
+#include <boost/msm/front/euml/algorithm.hpp>
+
+#endif //BOOST_MSM_FRONT_EUML_STL_H

test/external/boost/msm/front/euml/stt_grammar.hpp

@@ -0,0 +1,280 @@
+// 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_FRONT_EUML_STT_GRAMMAR_H
+#define BOOST_MSM_FRONT_EUML_STT_GRAMMAR_H
+
+#include <boost/msm/front/euml/common.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+#include <boost/msm/front/euml/operator.hpp>
+#include <boost/msm/front/euml/guard_grammar.hpp>
+#include <boost/msm/front/euml/state_grammar.hpp>
+
+namespace proto = boost::proto;
+
+namespace boost { namespace msm { namespace front { namespace euml
+{
+
+template <class SOURCE,class EVENT,class TARGET,class ACTION=none,class GUARD=none>
+struct TempRow
+{
+    typedef SOURCE  Source;
+    typedef EVENT   Evt;
+    typedef TARGET  Target;
+    typedef ACTION  Action;
+    typedef GUARD   Guard;
+};
+
+template <class TEMP_ROW>
+struct convert_to_row
+{
+    typedef Row<typename TEMP_ROW::Source,typename TEMP_ROW::Evt,typename TEMP_ROW::Target,
+                typename TEMP_ROW::Action,typename TEMP_ROW::Guard> type;
+};
+template <class TEMP_ROW>
+struct convert_to_internal_row
+{
+    typedef Internal<typename TEMP_ROW::Evt,
+                     typename TEMP_ROW::Action,typename TEMP_ROW::Guard> type;
+};
+// explicit + fork + entry point + exit point grammar
+struct BuildEntry
+    : proto::or_<
+        proto::when<
+                    proto::function<proto::terminal<proto::_>,proto::terminal<state_tag>,proto::terminal<state_tag> >,
+                    get_fct<proto::_child_c<0>,get_state_name<proto::_child_c<1>() >(),get_state_name<proto::_child_c<2>() >() >()
+        >
+    >
+{};
+
+// row grammar
+struct BuildNextStates
+   : proto::or_<
+        proto::when<
+                    proto::terminal<state_tag>,
+                    get_state_name<proto::_>()
+        >,
+        proto::when<
+                      BuildEntry,
+                      BuildEntry
+        >,
+        proto::when<
+                    proto::comma<BuildEntry,BuildEntry >,
+                    ::boost::mpl::push_back<
+                        make_vector_one_row<BuildEntry(proto::_left)>(),
+                        BuildEntry(proto::_right)>()
+        >,
+        proto::when <
+                    proto::comma<BuildNextStates,BuildEntry >,
+                    ::boost::mpl::push_back<
+                                BuildNextStates(proto::_left),
+                                BuildEntry(proto::_right) >()                
+        >
+   >
+{};
+
+template <class EventGuard,class ActionClass>
+struct fusion_event_action_guard 
+{
+    typedef TempRow<none,typename EventGuard::Evt,none,typename ActionClass::Action,typename EventGuard::Guard> type;
+};
+
+template <class SourceGuard,class ActionClass>
+struct fusion_source_action_guard 
+{
+    typedef TempRow<typename SourceGuard::Source,none,none,typename ActionClass::Action,typename SourceGuard::Guard> type;
+};
+
+template <class SourceClass,class EventClass>
+struct fusion_source_event_action_guard 
+{
+    typedef TempRow<typename SourceClass::Source,typename EventClass::Evt,
+                    none,typename EventClass::Action,typename EventClass::Guard> type;
+};
+template <class Left,class Right>
+struct fusion_left_right 
+{
+    typedef TempRow<typename Right::Source,typename Right::Evt,typename Left::Target
+                   ,typename Right::Action,typename Right::Guard> type;
+};
+
+struct BuildEventPlusGuard
+    : proto::or_<
+        proto::when<
+            proto::subscript<proto::terminal<event_tag>, GuardGrammar >,
+            TempRow<none,proto::_left,none,none, GuardGrammar(proto::_right)>(proto::_right)
+        >
+    >
+ {};
+
+struct BuildSourceState
+   : proto::or_<
+        proto::when<
+                    proto::terminal<state_tag>,
+                    get_state_name<proto::_>()
+        >,
+        proto::when<
+                    BuildEntry,
+                    BuildEntry
+        >
+   >
+{};
+
+struct BuildSourcePlusGuard
+    : proto::when<
+            proto::subscript<BuildSourceState,GuardGrammar >,
+            TempRow<BuildSourceState(proto::_left),none,none,none,GuardGrammar(proto::_right)>(proto::_right)
+        >
+{};
+
+struct BuildEvent
+    : proto::or_<
+        // just event without guard/action
+         proto::when<
+                proto::terminal<event_tag>,
+                TempRow<none,proto::_,none>() >
+        // event / action
+       , proto::when<
+                proto::divides<proto::terminal<event_tag>,ActionGrammar >,
+                TempRow<none,proto::_left,none,ActionGrammar(proto::_right) >(proto::_right) >
+        // event [ guard ]
+       , proto::when<
+                proto::subscript<proto::terminal<event_tag>,GuardGrammar >,
+                TempRow<none,proto::_left,none,none,GuardGrammar(proto::_right)>(proto::_right) >
+        // event [ guard ] / action 
+       , proto::when<
+                proto::divides<BuildEventPlusGuard, ActionGrammar>,
+                fusion_event_action_guard<BuildEventPlusGuard(proto::_left),
+                                          TempRow<none,none,none,ActionGrammar(proto::_right)>(proto::_right)
+                                           >() 
+                >
+        >
+{};
+struct BuildSource
+    : proto::or_<
+        // after == if just state without event or guard/action
+         proto::when<
+                BuildSourceState,
+                TempRow<BuildSourceState(proto::_),none,none>() >
+        // == source / action
+       , proto::when<
+                proto::divides<BuildSourceState,ActionGrammar >,
+                TempRow<BuildSourceState(proto::_left),none,none,ActionGrammar(proto::_right) >(proto::_right) >
+        // == source [ guard ]
+       , proto::when<
+                proto::subscript<BuildSourceState,GuardGrammar >,
+                TempRow<BuildSourceState(proto::_left),none,none,none,GuardGrammar(proto::_right)>(proto::_right) >
+        // == source [ guard ] / action 
+       , proto::when<
+                proto::divides<BuildSourcePlusGuard,
+                               ActionGrammar >,
+                fusion_source_action_guard<BuildSourcePlusGuard(proto::_left),
+                                           TempRow<none,none,none,ActionGrammar(proto::_right)>(proto::_right)
+                                           >() 
+                >
+        >
+{};
+
+struct BuildRight
+    : proto::or_<
+         proto::when<
+                proto::plus<BuildSource,BuildEvent >,
+                fusion_source_event_action_guard<BuildSource(proto::_left),BuildEvent(proto::_right)>()
+         >,
+         proto::when<
+                BuildSource,
+                BuildSource
+         >
+    >
+{};
+
+struct BuildRow
+    : proto::or_<
+        // grammar 1
+        proto::when<
+            proto::equal_to<BuildNextStates,BuildRight >,
+            convert_to_row<
+                fusion_left_right<TempRow<none,none,BuildNextStates(proto::_left)>,BuildRight(proto::_right)> >()
+        >,
+        // internal events
+        proto::when<
+            BuildRight,
+            convert_to_row<
+                fusion_left_right<TempRow<none,none,none>,BuildRight(proto::_)> >()
+        >,
+        // grammar 2
+        proto::when<
+            proto::equal_to<BuildRight,BuildNextStates>,
+            convert_to_row<
+                fusion_left_right<TempRow<none,none,BuildNextStates(proto::_right)>,BuildRight(proto::_left)> >()
+        >
+    >
+{};
+
+// stt grammar
+struct BuildStt
+   : proto::or_<
+        proto::when<
+                    proto::comma<BuildStt,BuildStt>,
+                    boost::mpl::push_back<BuildStt(proto::_left),BuildRow(proto::_right)>()
+                >,
+        proto::when <
+                    BuildRow,
+                    make_vector_one_row<BuildRow(proto::_)>()
+        >
+   >
+{};
+
+template <class Expr>
+typename ::boost::mpl::eval_if<
+    typename proto::matches<Expr,BuildStt>::type,
+    boost::result_of<BuildStt(Expr)>,
+    make_invalid_type>::type
+build_stt(Expr const& expr)
+{
+    return typename boost::result_of<BuildStt(Expr)>::type();
+}
+
+// internal stt grammar
+struct BuildInternalRow
+    :   proto::when<
+            BuildEvent,
+            convert_to_internal_row<
+                fusion_left_right<TempRow<none,none,none>,BuildEvent(proto::_)> >()
+        >
+{};
+struct BuildInternalStt
+   : proto::or_<
+        proto::when<
+                    proto::comma<BuildInternalStt,BuildInternalStt>,
+                    boost::mpl::push_back<BuildInternalStt(proto::_left),BuildInternalRow(proto::_right)>()
+                >,
+        proto::when <
+                    BuildInternalRow,
+                    make_vector_one_row<BuildInternalRow(proto::_)>()
+        >
+   >
+{};
+
+template <class Expr>
+typename ::boost::mpl::eval_if<
+    typename proto::matches<Expr,BuildInternalStt>::type,
+    boost::result_of<BuildInternalStt(Expr)>,
+    make_invalid_type>::type
+build_internal_stt(Expr const& expr)
+{
+    return typename boost::result_of<BuildInternalStt(Expr)>::type();
+}
+
+
+}}}}
+#endif //BOOST_MSM_FRONT_EUML_STT_GRAMMAR_H

test/external/boost/msm/front/euml/transformation.hpp

@@ -0,0 +1,335 @@
+// 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_FRONT_EUML_TRANSFORMATION_H
+#define BOOST_MSM_FRONT_EUML_TRANSFORMATION_H
+
+#include <algorithm>
+#include <boost/msm/front/euml/common.hpp>
+
+namespace boost { namespace msm { namespace front { namespace euml
+{
+#ifdef __STL_CONFIG_H
+BOOST_MSM_EUML_FUNCTION(FillN_ , std::fill_n , fill_n_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(Rotate_ , std::rotate , rotate_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(GenerateN_ , std::generate_n , generate_n_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+
+#else
+BOOST_MSM_EUML_FUNCTION(FillN_ , std::fill_n , fill_n_ , void , void )
+BOOST_MSM_EUML_FUNCTION(Rotate_ , std::rotate , rotate_ , void , void )
+BOOST_MSM_EUML_FUNCTION(GenerateN_ , std::generate_n , generate_n_ , void , void )
+#endif
+
+BOOST_MSM_EUML_FUNCTION(Copy_ , std::copy , copy_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(CopyBackward_ , std::copy_backward , copy_backward_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(Reverse_ , std::reverse , reverse_ , void , void )
+BOOST_MSM_EUML_FUNCTION(ReverseCopy_ , std::reverse_copy , reverse_copy_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(Remove_ , std::remove , remove_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(RemoveIf_ , std::remove_if , remove_if_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(RemoveCopy_ , std::remove_copy , remove_copy_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(RemoveCopyIf_ , std::remove_copy_if , remove_copy_if_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(Fill_ , std::fill , fill_ , void , void )
+BOOST_MSM_EUML_FUNCTION(Generate_ , std::generate , generate_ , void , void )
+BOOST_MSM_EUML_FUNCTION(Unique_ , std::unique , unique_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(UniqueCopy_ , std::unique_copy , unique_copy_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(RandomShuffle_ , std::random_shuffle , random_shuffle_ , void , void )
+BOOST_MSM_EUML_FUNCTION(RotateCopy_ , std::rotate_copy , rotate_copy_ , RESULT_TYPE_PARAM4 , RESULT_TYPE2_PARAM4 )
+BOOST_MSM_EUML_FUNCTION(Partition_ , std::partition , partition_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(StablePartition_ , std::stable_partition , stable_partition_ , RESULT_TYPE_PARAM1 , RESULT_TYPE2_PARAM1 )
+BOOST_MSM_EUML_FUNCTION(Sort_ , std::sort , sort_ , void , void )
+BOOST_MSM_EUML_FUNCTION(StableSort_ , std::stable_sort , stable_sort_ , void , void )
+BOOST_MSM_EUML_FUNCTION(PartialSort_ , std::partial_sort , partial_sort_ , void , void )
+BOOST_MSM_EUML_FUNCTION(PartialSortCopy_ , std::partial_sort_copy , partial_sort_copy_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(NthElement_ , std::nth_element , nth_element_ , void , void )
+BOOST_MSM_EUML_FUNCTION(Merge_ , std::merge , merge_ , RESULT_TYPE_PARAM5 , RESULT_TYPE2_PARAM5 )
+BOOST_MSM_EUML_FUNCTION(InplaceMerge_ , std::inplace_merge , inplace_merge_ , void , void )
+BOOST_MSM_EUML_FUNCTION(SetUnion_ , std::set_union , set_union_ , RESULT_TYPE_PARAM5 , RESULT_TYPE2_PARAM5 )
+BOOST_MSM_EUML_FUNCTION(PushHeap_ , std::push_heap , push_heap_ , void , void )
+BOOST_MSM_EUML_FUNCTION(PopHeap_ , std::pop_heap , pop_heap_ , void , void )
+BOOST_MSM_EUML_FUNCTION(MakeHeap_ , std::make_heap , make_heap_ , void , void )
+BOOST_MSM_EUML_FUNCTION(SortHeap_ , std::sort_heap , sort_heap_ , void , void )
+BOOST_MSM_EUML_FUNCTION(NextPermutation_ , std::next_permutation , next_permutation_ , bool , bool )
+BOOST_MSM_EUML_FUNCTION(PrevPermutation_ , std::prev_permutation , prev_permutation_ , bool , bool )
+BOOST_MSM_EUML_FUNCTION(InnerProduct_ , std::inner_product , inner_product_ , RESULT_TYPE_PARAM4 , RESULT_TYPE2_PARAM4 )
+BOOST_MSM_EUML_FUNCTION(PartialSum_ , std::partial_sum , partial_sum_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(AdjacentDifference_ , std::adjacent_difference , adjacent_difference_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(Replace_ , std::replace , replace_ , void , void )
+BOOST_MSM_EUML_FUNCTION(ReplaceIf_ , std::replace_if , replace_if_ , void , void )
+BOOST_MSM_EUML_FUNCTION(ReplaceCopy_ , std::replace_copy , replace_copy_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+BOOST_MSM_EUML_FUNCTION(ReplaceCopyIf_ , std::replace_copy_if , replace_copy_if_ , RESULT_TYPE_PARAM3 , RESULT_TYPE2_PARAM3 )
+
+
+
+template <class T>
+struct BackInserter_ : euml_action<BackInserter_<T> >
+{
+    template <class Event,class FSM,class STATE >
+    struct state_action_result 
+    {
+        typedef std::back_insert_iterator< 
+            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 std::back_insert_iterator< 
+            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 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 {};
+struct BackInserter_Helper: proto::extends< proto::terminal<back_inserter_tag>::type, BackInserter_Helper, sm_domain>
+{
+    BackInserter_Helper(){}
+    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
+#ifdef BOOST_MSVC 
+ ,class Arg6 
+#endif
+>
+    struct In
+    {
+        typedef BackInserter_<Arg1> type;
+    };
+};
+BackInserter_Helper const back_inserter_;
+
+template <class T>
+struct FrontInserter_ : euml_action<FrontInserter_<T> >
+{
+    template <class Event,class FSM,class STATE >
+    struct state_action_result 
+    {
+        typedef std::front_insert_iterator< 
+            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 std::front_insert_iterator< 
+            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 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 {};
+struct FrontInserter_Helper: proto::extends< proto::terminal<front_inserter_tag>::type, FrontInserter_Helper, sm_domain>
+{
+    FrontInserter_Helper(){}
+    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
+#ifdef BOOST_MSVC 
+ ,class Arg6 
+#endif
+>
+    struct In
+    {
+        typedef FrontInserter_<Arg1> type;
+    };
+};
+FrontInserter_Helper const front_inserter_;
+
+template <class T,class Pos>
+struct Inserter_ : euml_action<Inserter_<T,Pos> >
+{
+    template <class Event,class FSM,class STATE >
+    struct state_action_result 
+    {
+        typedef std::insert_iterator< 
+            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 std::insert_iterator< 
+            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 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 {};
+struct Inserter_Helper: proto::extends< proto::terminal<inserter_tag>::type, Inserter_Helper, sm_domain>
+{
+    Inserter_Helper(){}
+    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
+#ifdef BOOST_MSVC 
+ ,class Arg6 
+#endif
+>
+    struct In
+    {
+        typedef Inserter_<Arg1,Arg2> type;
+    };
+};
+Inserter_Helper const inserter_;
+
+template <class Param1, class Param2, class Param3, class Param4, class Param5, class Enable=void >
+struct Transform_ : euml_action<Transform_<Param1,Param2,Param3,Param4,Param5,Enable> >
+{
+};
+
+template <class Param1, class Param2, class Param3, class Param4, class Param5>
+struct Transform_<Param1,Param2,Param3,Param4,Param5,
+                  typename ::boost::enable_if<typename ::boost::is_same<Param5,void>::type >::type> 
+                    : euml_action<Transform_<Param1,Param2,Param3,Param4,Param5> >
+{
+    template <class Event,class FSM,class STATE >
+    struct state_action_result 
+    {
+        typedef typename get_result_type2<Param3,Event,FSM,STATE>::type type;
+    };
+    template <class EVT,class FSM,class SourceState,class TargetState>
+    struct transition_action_result 
+    {
+        typedef typename get_result_type<Param3,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 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 
+     operator()(Event const& evt,FSM& fsm,STATE& state )const
+    {
+        return std::transform(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state),
+                              Param4()(evt,fsm,state));        
+    }
+};
+
+template <class Param1, class Param2, class Param3, class Param4, class Param5>
+struct Transform_<Param1,Param2,Param3,Param4,Param5,
+               typename ::boost::disable_if<typename ::boost::is_same<Param5,void>::type >::type> 
+                    : euml_action<Transform_<Param1,Param2,Param3,Param4,Param5> >
+{
+    template <class Event,class FSM,class STATE >
+    struct state_action_result 
+    {
+        typedef typename get_result_type2<Param4,Event,FSM,STATE>::type type;
+    };
+    template <class EVT,class FSM,class SourceState,class TargetState>
+    struct transition_action_result 
+    {
+        typedef typename get_result_type<Param4,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 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 
+     operator()(Event const& evt,FSM& fsm,STATE& state )const
+    {
+        return std::transform (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state),
+                               Param4()(evt,fsm,state),Param5()(evt,fsm,state));
+    }
+};
+struct transform_tag {};
+struct Transform_Helper: proto::extends< proto::terminal<transform_tag>::type, Transform_Helper, sm_domain>
+{
+    Transform_Helper(){}
+    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
+#ifdef BOOST_MSVC 
+ ,class Arg6 
+#endif
+>
+    struct In
+    {
+        typedef Transform_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
+    };
+};
+Transform_Helper const transform_;
+
+}}}}
+
+#endif //BOOST_MSM_FRONT_EUML_TRANSFORMATION_H

test/external/boost/msm/front/functor_row.hpp

@@ -0,0 +1,338 @@
+// 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_FRONT_FUNCTOR_ROW_H
+#define BOOST_MSM_FRONT_FUNCTOR_ROW_H
+
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/has_xxx.hpp>
+
+#include <boost/typeof/typeof.hpp>
+
+#include <boost/msm/back/common_types.hpp>
+#include <boost/msm/row_tags.hpp>
+#include <boost/msm/common.hpp>
+#include <boost/msm/front/completion_event.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_MPL_HAS_XXX_TRAIT_DEF(deferring_action)
+
+namespace boost { namespace msm { namespace front
+{
+    template <class Func,class Enable=void>
+    struct get_functor_return_value 
+    {
+        static const ::boost::msm::back::HandledEnum value = ::boost::msm::back::HANDLED_TRUE;
+    };
+    template <class Func>
+    struct get_functor_return_value<Func, 
+        typename ::boost::enable_if<
+            typename has_deferring_action<Func>::type 
+        >::type
+    > 
+    {
+        static const ::boost::msm::back::HandledEnum value = ::boost::msm::back::HANDLED_DEFERRED;
+    };
+
+    template <class SOURCE,class EVENT,class TARGET,class ACTION=none,class GUARD=none>
+    struct Row
+    {
+        typedef SOURCE  Source;
+        typedef EVENT   Evt;
+        typedef TARGET  Target;
+        typedef ACTION  Action;
+        typedef GUARD   Guard;
+        // action plus guard
+        typedef row_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            Action()(evt,fsm,src,tgt);
+            return get_functor_return_value<Action>::value;
+        }
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static bool guard_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt,AllStates&)
+        {
+            // create functor, call it
+            return Guard()(evt,fsm,src,tgt);
+        }
+    };
+
+    template<class SOURCE,class EVENT,class TARGET>
+    struct Row<SOURCE,EVENT,TARGET,none,none>
+    {
+        typedef SOURCE  Source;
+        typedef EVENT   Evt;
+        typedef TARGET  Target;
+        typedef none    Action;
+        typedef none    Guard;
+        // no action, no guard
+        typedef _row_tag row_type_tag;
+    };
+    template<class SOURCE,class EVENT,class TARGET,class ACTION>
+    struct Row<SOURCE,EVENT,TARGET,ACTION,none>
+    {
+        typedef SOURCE  Source;
+        typedef EVENT   Evt;
+        typedef TARGET  Target;
+        typedef ACTION  Action;
+        typedef none    Guard;
+        // no guard
+        typedef a_row_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            Action()(evt,fsm,src,tgt);
+            return get_functor_return_value<Action>::value;
+        }
+    };
+    template<class SOURCE,class EVENT,class TARGET,class GUARD>
+    struct Row<SOURCE,EVENT,TARGET,none,GUARD>
+    {
+        typedef SOURCE  Source;
+        typedef EVENT   Evt;
+        typedef TARGET  Target;
+        typedef none    Action;
+        typedef GUARD   Guard;
+        // no action
+        typedef g_row_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static bool guard_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            return Guard()(evt,fsm,src,tgt);
+        }
+    };
+    // internal transitions
+    template<class SOURCE,class EVENT,class ACTION>
+    struct Row<SOURCE,EVENT,none,ACTION,none>
+    {
+        typedef SOURCE  Source;
+        typedef EVENT   Evt;
+        typedef Source  Target;
+        typedef ACTION  Action;
+        typedef none    Guard;
+        // no guard
+        typedef a_irow_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            Action()(evt,fsm,src,tgt);
+            return get_functor_return_value<Action>::value;
+        }
+    };
+    template<class SOURCE,class EVENT,class GUARD>
+    struct Row<SOURCE,EVENT,none,none,GUARD>
+    {
+        typedef SOURCE  Source;
+        typedef EVENT   Evt;
+        typedef Source  Target;
+        typedef none    Action;
+        typedef GUARD   Guard;
+        // no action
+        typedef g_irow_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static bool guard_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            return Guard()(evt,fsm,src,tgt);
+        }
+    };
+    template<class SOURCE,class EVENT,class ACTION,class GUARD>
+    struct Row<SOURCE,EVENT,none,ACTION,GUARD>
+    {
+        typedef SOURCE  Source;
+        typedef EVENT   Evt;
+        typedef Source  Target;
+        typedef ACTION  Action;
+        typedef GUARD   Guard;
+        // action + guard
+        typedef irow_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            Action()(evt,fsm,src,tgt);
+            return get_functor_return_value<Action>::value;
+        }
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static bool guard_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            return Guard()(evt,fsm,src,tgt);
+        }
+    };
+    template<class SOURCE,class EVENT>
+    struct Row<SOURCE,EVENT,none,none,none>
+    {
+        typedef SOURCE  Source;
+        typedef EVENT   Evt;
+        typedef Source  Target;
+        typedef none    Action;
+        typedef none    Guard;
+        // no action, no guard
+        typedef _irow_tag row_type_tag;
+    };
+    template<class TGT>
+    struct get_row_target
+    {
+        typedef typename TGT::Target type;
+    };
+
+    template <class EVENT,class ACTION=none,class GUARD=none>
+    struct Internal
+    {
+        typedef EVENT   Evt;
+        typedef ACTION  Action;
+        typedef GUARD   Guard;
+        // action plus guard
+        typedef sm_i_row_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            Action()(evt,fsm,src,tgt);
+            return get_functor_return_value<Action>::value;
+        }
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static bool guard_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            return Guard()(evt,fsm,src,tgt);
+        }
+    };
+
+    template<class EVENT,class ACTION>
+    struct Internal<EVENT,ACTION,none>
+    {
+        typedef EVENT   Evt;
+        typedef ACTION  Action;
+        typedef none    Guard;
+        // no guard
+        typedef sm_a_i_row_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            Action()(evt,fsm,src,tgt);
+            return get_functor_return_value<Action>::value;
+        }
+    };
+    template<class EVENT,class GUARD>
+    struct Internal<EVENT,none,GUARD>
+    {
+        typedef EVENT   Evt;
+        typedef none    Action;
+        typedef GUARD   Guard;
+        // no action
+        typedef sm_g_i_row_tag row_type_tag;
+        template <class EVT,class FSM,class SourceState,class TargetState,class AllStates>
+        static bool guard_call(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt, AllStates&)
+        {
+            // create functor, call it
+            return Guard()(evt,fsm,src,tgt);
+        }
+    };
+    template<class EVENT>
+    struct Internal<EVENT,none,none>
+    {
+        typedef EVENT   Evt;
+        typedef none    Action;
+        typedef none    Guard;
+        // no action, no guard
+        typedef sm__i_row_tag row_type_tag;
+    };
+    struct event_tag{};
+    struct action_tag{};
+    struct state_action_tag{};
+    struct flag_tag{};
+    struct config_tag{};
+    struct not_euml_tag{};
+
+    template <class Sequence>
+    struct ActionSequence_
+    {
+        typedef Sequence sequence;
+        template <class Event,class FSM,class STATE >
+        struct state_action_result 
+        {
+            typedef void type;
+        };
+        template <class EVT,class FSM,class STATE>
+        struct Call
+        {
+            Call(EVT const& evt,FSM& fsm,STATE& state):
+        evt_(evt),fsm_(fsm),state_(state){}
+        template <class FCT>
+        void operator()(::boost::msm::wrap<FCT> const& )
+        {
+            FCT()(evt_,fsm_,state_);
+        }
+        private:
+            EVT const&  evt_;
+            FSM&        fsm_;
+            STATE&      state_;
+        };
+        template <class EVT,class FSM,class SourceState,class TargetState>
+        struct transition_action_result 
+        {
+            typedef void type;
+        };
+        template <class EVT,class FSM,class SourceState,class TargetState>
+        struct Call2
+        {
+            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::wrap<FCT> const& )
+        {
+            FCT()(evt_,fsm_,src_,tgt_);
+        }
+        private:
+            EVT const & evt_;
+            FSM& fsm_;
+            SourceState& src_;
+            TargetState& tgt_;
+        };
+
+        typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+        template <class EVT,class FSM,class STATE>
+        void operator()(EVT const& evt,FSM& fsm,STATE& state)
+        {
+            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::wrap< ::boost::mpl::placeholders::_1> >
+                (Call2<EVT,FSM,SourceState,TargetState>(evt,fsm,src,tgt));
+        }
+    };
+
+    // functor pre-defined for basic functionality
+    struct Defer 
+    {
+        // mark as deferring to avoid stack overflows in certain conditions
+        typedef int deferring_action;
+        template <class EVT,class FSM,class SourceState,class TargetState>
+        void operator()(EVT const& evt,FSM& fsm,SourceState& ,TargetState& ) const
+        {
+            fsm.defer_event(evt);
+        }
+    };
+}}}
+#endif //BOOST_MSM_FRONT_FUNCTOR_ROW_H

test/external/boost/msm/front/internal_row.hpp

@@ -0,0 +1,105 @@
+// 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_INTERNAL_ROW_HPP
+#define BOOST_MSM_INTERNAL_ROW_HPP
+
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/include/at_key.hpp>
+#include <boost/msm/back/common_types.hpp>
+#include <boost/msm/row_tags.hpp>
+#include <boost/msm/front/detail/row2_helper.hpp>
+
+namespace boost { namespace msm { namespace front
+{
+    template<
+        class Event
+        , typename CalledForAction
+        , void (CalledForAction::*action)(Event const&)
+    >
+    struct a_internal
+    {
+        typedef sm_a_i_row_tag row_type_tag;
+        typedef Event Evt;
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt, 
+                                AllStates& all_states)
+        {
+            // in this front-end, we don't need to know source and target states
+            ::boost::msm::front::detail::row2_action_helper<CalledForAction,Event,action>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+    };
+
+    template<
+        class Event
+        , typename CalledForAction
+        , void (CalledForAction::*action)(Event const&)
+        , typename CalledForGuard
+        , bool (CalledForGuard::*guard)(Event const&)
+    >
+    struct internal
+    {
+        typedef sm_i_row_tag row_type_tag;
+        typedef Event Evt;
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt, 
+                                AllStates& all_states)
+        {
+            // in this front-end, we don't need to know source and target states
+            ::boost::msm::front::detail::row2_action_helper<CalledForAction,Event,action>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+        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)
+        {
+            // in this front-end, we don't need to know source and target states
+            return ::boost::msm::front::detail::row2_guard_helper<CalledForGuard,Event,guard>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
+        }
+    };
+    template<
+        class Event
+        , typename CalledForGuard
+        , bool (CalledForGuard::*guard)(Event const&)
+    >
+    struct g_internal
+    {
+        typedef sm_g_i_row_tag row_type_tag;
+        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)
+        {
+            // in this front-end, we don't need to know source and target states
+            return ::boost::msm::front::detail::row2_guard_helper<CalledForGuard,Event,guard>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
+        }
+    };
+    template<
+        class Event
+    >
+    struct _internal
+    {
+        typedef sm__i_row_tag row_type_tag;
+        typedef Event Evt;
+    };
+}}}
+
+#endif //BOOST_MSM_INTERNAL_ROW_HPP
+

test/external/boost/msm/front/row2.hpp

@@ -0,0 +1,204 @@
+// 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_ROW2_HPP
+#define BOOST_MSM_ROW2_HPP
+
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/include/at_key.hpp>
+#include <boost/msm/back/common_types.hpp>
+#include <boost/msm/row_tags.hpp>
+#include <boost/msm/front/detail/row2_helper.hpp>
+
+namespace boost { namespace msm { namespace front
+{
+    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
+        , typename CalledForAction
+        , void (CalledForAction::*action)(Event const&)
+    >
+    struct a_row2
+    {
+        typedef a_row_tag row_type_tag;
+        typedef T1 Source;
+        typedef T2 Target;
+        typedef Event Evt;
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt, 
+                                AllStates& all_states)
+        {
+            // in this front-end, we don't need to know source and target states
+            ::boost::msm::front::detail::row2_action_helper<CalledForAction,Event,action>::template call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+    };
+
+    template<
+        typename T1
+        , class Event
+        , typename T2
+        , typename CalledForAction
+        , void (CalledForAction::*action)(Event const&)
+        , typename CalledForGuard
+        , bool (CalledForGuard::*guard)(Event const&)
+    >
+    struct row2
+    {
+        typedef row_tag row_type_tag;
+        typedef T1 Source;
+        typedef T2 Target;
+        typedef Event Evt;
+        template <class FSM,class SourceState,class TargetState, class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt, 
+                                AllStates& all_states)
+        {
+            // in this front-end, we don't need to know source and target states
+            ::boost::msm::front::detail::row2_action_helper<CalledForAction,Event,action>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+        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)
+        {
+            // in this front-end, we don't need to know source and target states
+            return ::boost::msm::front::detail::row2_guard_helper<CalledForGuard,Event,guard>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
+        }
+    };
+    template<
+        typename T1
+        , class Event
+        , typename T2
+        , typename CalledForGuard
+        , bool (CalledForGuard::*guard)(Event const&)
+    >
+    struct g_row2
+    {
+        typedef g_row_tag row_type_tag;
+        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)
+        {
+            // in this front-end, we don't need to know source and target states
+            return ::boost::msm::front::detail::row2_guard_helper<CalledForGuard,Event,guard>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
+        }
+    };
+    // internal transitions
+    template<
+        typename T1
+        , class Event
+        , typename CalledForAction
+        , void (CalledForAction::*action)(Event const&)
+    >
+    struct a_irow2
+    {
+        typedef a_irow_tag row_type_tag;
+        typedef T1 Source;
+        typedef T1 Target;
+        typedef Event Evt;
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt, 
+                                AllStates& all_states)
+        {
+            // in this front-end, we don't need to know source and target states
+            ::boost::msm::front::detail::row2_action_helper<CalledForAction,Event,action>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+    };
+
+    template<
+        typename T1
+        , class Event
+        , typename CalledForAction
+        , void (CalledForAction::*action)(Event const&)
+        , typename CalledForGuard
+        , bool (CalledForGuard::*guard)(Event const&)
+    >
+    struct irow2
+    {
+        typedef irow_tag row_type_tag;
+        typedef T1 Source;
+        typedef T1 Target;
+        typedef Event Evt;
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum action_call(FSM& fsm,Event const& evt,SourceState& src,TargetState& tgt, 
+                                AllStates& all_states)
+        {
+            // in this front-end, we don't need to know source and target states
+            ::boost::msm::front::detail::row2_action_helper<CalledForAction,Event,action>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForAction,FSM>::type::value>());
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+        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)
+        {
+            // in this front-end, we don't need to know source and target states
+            return ::boost::msm::front::detail::row2_guard_helper<CalledForGuard,Event,guard>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
+        }
+    };
+    template<
+        typename T1
+        , class Event
+        , typename CalledForGuard
+        , bool (CalledForGuard::*guard)(Event const&)
+    >
+    struct g_irow2
+    {
+        typedef g_irow_tag row_type_tag;
+        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)
+        {
+            // in this front-end, we don't need to know source and target states
+            return ::boost::msm::front::detail::row2_guard_helper<CalledForGuard,Event,guard>::call_helper
+                (fsm,evt,src,tgt,all_states,
+                ::boost::mpl::bool_< ::boost::is_base_of<CalledForGuard,FSM>::type::value>());
+        }
+    };
+
+}}}
+
+#endif //BOOST_MSM_ROW2_HPP
+

test/external/boost/msm/front/state_machine_def.hpp

@@ -0,0 +1,215 @@
+// 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_FRONT_STATEMACHINE_DEF_H
+#define BOOST_MSM_FRONT_STATEMACHINE_DEF_H
+
+#include <exception>
+#include <boost/assert.hpp>
+
+#include <boost/mpl/vector.hpp>
+
+#include <boost/msm/row_tags.hpp>
+#include <boost/msm/back/common_types.hpp>
+#include <boost/msm/front/states.hpp>
+#include <boost/msm/front/completion_event.hpp>
+#include <boost/msm/front/common_states.hpp>
+
+namespace boost { namespace msm { namespace front
+{
+
+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;
+    // customization (message queue, exceptions)
+    typedef ::boost::mpl::vector0<>               configuration;
+
+    typedef BaseState                             BaseAllStates;
+    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;
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum 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);
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+    };
+
+    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 row_tag row_type_tag;
+        typedef T1 Source;
+        typedef T2 Target;
+        typedef Event Evt;
+        template <class FSM,class SourceState,class TargetState, class AllStates>
+        static ::boost::msm::back::HandledEnum 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);
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static bool guard_call(FSM& fsm,Event const& evt,SourceState&,TargetState&,AllStates&)
+        {
+            // 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
+    {
+        typedef g_row_tag row_type_tag;
+        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&)
+        {
+            // in this front-end, we don't need to know source and target states
+            return (fsm.*guard)(evt);
+        }
+    };
+    // internal transitions
+    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;
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum 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);
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+    };
+
+    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;
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static ::boost::msm::back::HandledEnum 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);
+            return ::boost::msm::back::HANDLED_TRUE;
+        }
+        template <class FSM,class SourceState,class TargetState,class AllStates>
+        static bool guard_call(FSM& fsm,Event const& evt,SourceState&,TargetState&,AllStates&)
+        {
+            // 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
+    {
+        typedef g_irow_tag row_type_tag;
+        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&)
+        {
+            // in this front-end, we don't need to know source and target states
+            return (fsm.*guard)(evt);
+        }
+    };
+    // internal row withou action or guard. Does nothing except forcing the event to be ignored.
+    template<
+        typename T1
+        , class Event
+    >
+    struct _irow
+    {
+        typedef _irow_tag row_type_tag;
+        typedef T1 Source;
+        typedef T1 Target;
+        typedef Event Evt;
+    };
+protected:
+    // Default no-transition handler. Can be replaced in the Derived SM class.
+    template <class FSM,class Event>
+    void no_transition(Event const& ,FSM&, int state)
+    {
+        BOOST_ASSERT(false);
+    }
+    // default exception handler. Can be replaced in the Derived SM class.
+    template <class FSM,class Event>
+    void exception_caught (Event const&,FSM&,std::exception& )
+    {
+        BOOST_ASSERT(false);
+    }
+};
+
+
+} } }// boost::msm::front
+#endif //BOOST_MSM_FRONT_STATEMACHINE_DEF_H
+

test/external/boost/msm/front/states.hpp

@@ -0,0 +1,128 @@
+// 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_FRONT_STATES_H
+#define BOOST_MSM_FRONT_STATES_H
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/msm/front/common_states.hpp>
+#include <boost/msm/row_tags.hpp>
+
+namespace boost { namespace msm { namespace front
+{
+
+struct no_sm_ptr 
+{
+    // tags
+    typedef ::boost::mpl::bool_<false>   needs_sm;
+};
+struct sm_ptr 
+{
+    // tags
+    typedef ::boost::mpl::bool_<true>    needs_sm;
+};
+// kept for backward compatibility
+struct NoSMPtr 
+{
+    // tags
+    typedef ::boost::mpl::bool_<false>   needs_sm;
+};
+struct SMPtr 
+{
+    // tags
+    typedef ::boost::mpl::bool_<true>    needs_sm;
+};
+
+// provides the typedefs and interface. Concrete states derive from it.
+// template argument: pointer-to-fsm policy
+template<class BASE = default_base_state,class SMPtrPolicy = no_sm_ptr>
+struct state :  public boost::msm::front::detail::state_base<BASE>, SMPtrPolicy
+{
+    // tags
+    // default: no flag
+    typedef ::boost::mpl::vector0<>       flag_list;
+    //default: no deferred events
+    typedef ::boost::mpl::vector0<>       deferred_events;
+};
+
+// terminate state simply defines the TerminateFlag flag
+// template argument: pointer-to-fsm policy
+template<class BASE = default_base_state,class SMPtrPolicy = no_sm_ptr>
+struct terminate_state : public boost::msm::front::detail::state_base<BASE>, SMPtrPolicy
+{
+    // tags
+    typedef ::boost::mpl::vector<boost::msm::TerminateFlag>      flag_list;
+    //default: no deferred events
+    typedef ::boost::mpl::vector0<>                               deferred_events;
+};
+
+// terminate state simply defines the InterruptedFlag and EndInterruptFlag<EndInterruptEvent> flags
+// template argument: event which ends the interrupt
+// template argument: pointer-to-fsm policy
+template <class EndInterruptEvent,class BASE = default_base_state,class SMPtrPolicy = no_sm_ptr>
+struct interrupt_state : public boost::msm::front::detail::state_base<BASE>, SMPtrPolicy
+{
+    // tags
+    typedef ::boost::mpl::vector<boost::msm::InterruptedFlag,
+        boost::msm::EndInterruptFlag<EndInterruptEvent> >       
+        flag_list;
+    //default: no deferred events
+    typedef ::boost::mpl::vector0<>                           deferred_events;
+};
+
+// not a state but a bunch of extra typedefs to handle direct entry into a composite state. To be derived from
+// template argument: zone index of this state
+template <int ZoneIndex=-1>
+struct explicit_entry 
+{
+    typedef int explicit_entry_state;
+    enum {zone_index=ZoneIndex};
+};
+
+// to be derived from. Makes a type an entry (pseudo) state. Actually an almost full-fledged state
+// template argument: containing composite
+// template argument: zone index of this state
+// template argument: pointer-to-fsm policy
+template<int ZoneIndex=-1,class BASE = default_base_state,class SMPtrPolicy = no_sm_ptr>
+struct entry_pseudo_state
+    :  public boost::msm::front::detail::state_base<BASE>,SMPtrPolicy
+{
+    // tags
+    typedef int                          pseudo_entry;
+    enum {zone_index=ZoneIndex};
+    typedef int explicit_entry_state;
+    // default: no flag
+    typedef ::boost::mpl::vector0<>       flag_list;
+    //default: no deferred events
+    typedef ::boost::mpl::vector0<>       deferred_events;
+};
+
+// to be derived from. Makes a state an exit (pseudo) state. Actually an almost full-fledged state
+// template argument: event to forward
+// template argument: pointer-to-fsm policy
+template<class Event,class BASE = default_base_state,class SMPtrPolicy = no_sm_ptr>
+struct exit_pseudo_state : public boost::msm::front::detail::state_base<BASE> , SMPtrPolicy
+{
+    typedef Event       event;
+    typedef BASE        Base;
+    typedef SMPtrPolicy PtrPolicy;
+    typedef int         pseudo_exit;
+
+    // default: no flag
+    typedef ::boost::mpl::vector< > flag_list;
+    //default: no deferred events
+    typedef ::boost::mpl::vector0<>  deferred_events;
+};
+
+}}}
+
+#endif //BOOST_MSM_FRONT_STATES_H
+

test/external/boost/msm/mpl_graph/adjacency_list_graph.hpp

@@ -0,0 +1,35 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_ADJACENCY_LIST_GRAPH_HPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_ADJACENCY_LIST_GRAPH_HPP_INCLUDED
+
+// graph implementation based on an adjacency list
+// sequence< pair< source_vertex, sequence< pair<edge, target_vertex> > > >
+
+// adjacency_list_graph labels such a sequence as manipulable by the metafunctions
+// in the corresponding implementation header detail/adjacency_list_graph.ipp
+// to produce the metadata structures needed by mpl_graph.hpp 
+
+// the public interface
+#include <boost/msm/mpl_graph/mpl_graph.hpp>
+
+// the implementation
+#include <boost/msm/mpl_graph/detail/adjacency_list_graph.ipp>
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+   
+template<typename AdjacencyList>
+struct adjacency_list_graph {
+    typedef detail::adjacency_list_tag representation;
+    typedef AdjacencyList data;
+};
+
+}
+}
+}
+
+#endif // BOOST_MSM_MPL_GRAPH_ADJACENCY_LIST_GRAPH_HPP_INCLUDED

test/external/boost/msm/mpl_graph/breadth_first_search.hpp

@@ -0,0 +1,167 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_BREADTH_FIRST_SEARCH_HPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_BREADTH_FIRST_SEARCH_HPP_INCLUDED
+
+#include <boost/msm/mpl_graph/mpl_graph.hpp>
+
+#include <boost/mpl/has_key.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/pair.hpp>
+#include <boost/mpl/map.hpp>
+#include <boost/mpl/has_key.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/remove.hpp>
+
+#include "search_colors.hpp"
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+
+// bfs takes a visitor which has all the bgl-like metafunctions encapsulated in an 
+// "operations" member class, and also a state.  the operations are expected to return a new state
+struct bfs_default_visitor_operations {
+    template<typename Vertex, typename Graph, typename State>
+    struct initialize_vertex {
+        typedef State type;       
+    };
+    
+    template<typename Vertex, typename Graph, typename State>
+    struct discover_vertex {
+        typedef State type;       
+    };
+    
+    template<typename Vertex, typename Graph, typename State>
+    struct examine_vertex {
+        typedef State type;       
+    };
+    
+    template<typename Vertex, typename Graph, typename State>
+    struct examine_edge {
+        typedef State type;       
+    };
+        
+    template<typename Edge, typename Graph, typename State>
+    struct tree_edge {
+        typedef State type;
+    };
+    
+    template<typename Edge, typename Graph, typename State>
+    struct non_tree_edge {
+        typedef State type;
+    };
+    
+    template<typename Edge, typename Graph, typename State>
+    struct gray_target {
+        typedef State type;
+    };  
+    
+    template<typename Edge, typename Graph, typename State>
+    struct black_target {
+        typedef State type;
+    };  
+    
+    template<typename Vertex, typename Graph, typename State>
+    struct finish_vertex {
+        typedef State type;       
+    };
+};
+
+namespace detail {
+
+template<typename Graph, typename VisitorOps, typename VCQState, typename Edge>
+struct bfs_run_queue_examine_edge {
+    typedef typename VisitorOps::template examine_edge<Edge, Graph, typename mpl::at_c<VCQState, 0>::type>::type visitor_state;
+    typedef typename mpl::at_c<VCQState, 1>::type color_state;
+    typedef typename mpl::at_c<VCQState, 2>::type vertex_queue;
+
+    typedef typename mpl::if_<typename boost::is_same<typename search_color_map_ops::template get_color<typename mpl_graph::target<Edge, Graph>::type, color_state>::type, search_colors::White>::type,
+         // unseen target: tree edge, discover target, paint it gray, and enqueue
+         mpl::vector<typename VisitorOps::template discover_vertex<typename mpl_graph::target<Edge, Graph>::type, Graph,
+                                                                            typename VisitorOps::template tree_edge<Edge, Graph, visitor_state>::type>::type,
+                     typename search_color_map_ops::template set_color<typename mpl_graph::target<Edge, Graph>::type, search_colors::Gray, color_state>::type,
+                     typename mpl::push_back<vertex_queue, typename mpl_graph::target<Edge, Graph>::type >::type >,
+         // seen
+         mpl::vector<typename mpl::if_<typename boost::is_same<typename search_color_map_ops::template get_color<mpl_graph::target<Edge, Graph>, color_state>, 
+                                             search_colors::Gray>::type,
+                              typename VisitorOps::template gray_target<Edge, Graph, visitor_state>::type,
+                              typename VisitorOps::template black_target<Edge, Graph, visitor_state>::type>::type,
+                     color_state,
+                     vertex_queue> 
+         >::type type; 
+};
+
+// runs bfs on a queue, passing the new queue forward on recursion
+// returns pair<visitor_state, color_state>
+template<typename Graph, typename VertexQueue, typename VisitorOps, typename VisitorState, typename ColorMap>
+struct bfs_run_queue {
+    // enter vertex
+    typedef typename mpl::front<VertexQueue>::type Vertex;
+    typedef typename mpl::pop_front<VertexQueue>::type Tail;
+    typedef typename VisitorOps::template examine_vertex<Vertex, Graph, VisitorState>::type examined_state;
+    
+    // loop over out edges
+    typedef typename mpl::template 
+        fold<typename mpl_graph::out_edges<Vertex, Graph>::type, 
+             mpl::vector<examined_state, ColorMap, Tail>,
+             bfs_run_queue_examine_edge<Graph, VisitorOps, mpl::_1, mpl::_2>
+            >::type did_edges;
+            
+    typedef typename VisitorOps::template 
+        finish_vertex<Vertex, Graph, typename mpl::at_c<did_edges, 0>::type>::type 
+            finished_vertex; 
+    // does map insert always overwrite?  i seem to remember this not working on msvc once
+    typedef typename search_color_map_ops::template 
+        set_color<Vertex, search_colors::Black, typename mpl::at_c<did_edges, 1>::type>::type 
+            colored_vertex;
+    typedef typename mpl::at_c<did_edges, 2>::type queued_targets;
+
+    typedef typename 
+        mpl::if_<typename mpl::empty<queued_targets>::type,
+                 mpl::pair<finished_vertex, colored_vertex>,
+                 bfs_run_queue<Graph, queued_targets,
+                               VisitorOps, finished_vertex,
+                               colored_vertex> >::type::type type;
+};
+
+} // namespace detail
+
+template<typename Graph, typename VisitorOps, typename VisitorState, 
+         typename Vertex, 
+         typename ColorMap = create_search_color_map::type >
+struct breadth_first_search {
+    typedef typename VisitorOps::template 
+        discover_vertex<Vertex, Graph, VisitorState>::type 
+            discovered_state;
+    typedef typename search_color_map_ops::template 
+        set_color<Vertex, search_colors::Gray, ColorMap>::type 
+            discovered_colors;
+    typedef typename detail::
+        bfs_run_queue<Graph, mpl::vector<Vertex>, 
+                      VisitorOps, discovered_state, 
+                      discovered_colors>::type type;
+};
+
+template<typename Graph, typename VisitorOps, typename VisitorState,
+         typename FirstVertex = typename mpl::front<typename mpl_graph::vertices<Graph>::type>::type,
+         typename ColorMap = create_search_color_map::type>
+struct breadth_first_search_all : // visit "first" first, then visit any still white
+    mpl::fold<typename mpl_graph::vertices<Graph>::type,
+              typename breadth_first_search<Graph, VisitorOps, VisitorState, FirstVertex, ColorMap>::type,
+              mpl::if_<boost::is_same<search_color_map_ops::template get_color<mpl::_2, mpl::second<mpl::_1> >,
+                                      search_colors::White>,
+                       breadth_first_search<Graph, VisitorOps, mpl::first<mpl::_1>,
+                                            mpl::_2, mpl::second<mpl::_1> >,
+                       mpl::_1> >   
+{};
+
+} // namespace mpl_graph
+} // namespace msm
+} // namespace boost
+
+
+#endif // BOOST_MSM_MPL_GRAPH_BREADTH_FIRST_SEARCH_HPP_INCLUDED

test/external/boost/msm/mpl_graph/depth_first_search.hpp

@@ -0,0 +1,122 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_DEPTH_FIRST_SEARCH_HPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_DEPTH_FIRST_SEARCH_HPP_INCLUDED
+
+#include <boost/msm/mpl_graph/mpl_graph.hpp>
+
+#include <boost/mpl/has_key.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/pair.hpp>
+#include <boost/mpl/map.hpp>
+#include <boost/mpl/has_key.hpp>
+
+#include "search_colors.hpp"
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+
+// dfs takes a visitor which has all the bgl-like metafunctions encapsulated in an 
+// "operations" member class, and also a state.  the operations are expected to return a new state
+// in addition, the visitor operations are expected to update the colors of vertices
+// and need to support a new metafunction get_color<Vertex, State>
+
+struct dfs_default_visitor_operations {
+    template<typename Vertex, typename Graph, typename State>
+    struct initialize_vertex {
+        typedef State type;       
+    };
+    
+    template<typename Vertex, typename Graph, typename State>
+    struct discover_vertex {
+        typedef State type;       
+    };
+    
+    template<typename Vertex, typename Graph, typename State>
+    struct finish_vertex {
+        typedef State type;       
+    };
+        
+    template<typename Edge, typename Graph, typename State>
+    struct tree_edge {
+        typedef State type;
+    };
+    
+    template<typename Edge, typename Graph, typename State>
+    struct back_edge {
+        typedef State type;
+    };
+    
+    template<typename Edge, typename Graph, typename State>
+    struct forward_or_cross_edge {
+        typedef State type;
+    };  
+};
+
+// requires IncidenceGraph
+// returns pair<VisitorState, ColorState>
+template<typename Graph, typename VisitorOps, typename VisitorState,
+         typename Vertex, 
+         typename ColorState = create_search_color_map::type >
+struct depth_first_search {
+    // enter vertex
+    typedef typename VisitorOps::template 
+        discover_vertex<Vertex, Graph, VisitorState>::type 
+            discovered_state;
+    typedef typename search_color_map_ops::template 
+        set_color<Vertex, search_colors::Gray, ColorState>::type 
+            discovered_colors;
+            
+    // loop over out edges
+    typedef typename 
+        mpl::fold<typename mpl_graph::out_edges<Vertex, Graph>::type, 
+                  mpl::pair<discovered_state, discovered_colors>,
+                  mpl::if_<boost::is_same<search_color_map_ops::get_color<mpl_graph::target<mpl::_2, Graph>, mpl::second<mpl::_1> >, 
+                                          search_colors::White>,
+                           // unseen target: recurse
+                           depth_first_search<Graph, 
+                                              VisitorOps, typename VisitorOps::template tree_edge<mpl::_2, Graph, mpl::first<mpl::_1> >, 
+                                              mpl_graph::target<mpl::_2, Graph>, 
+                                              mpl::second<mpl::_1> >,
+                           // seen: back or forward edge
+                           mpl::pair<mpl::if_<boost::is_same<typename search_color_map_ops::template 
+                                                 get_color<mpl_graph::target<mpl::_2, Graph>, mpl::second<mpl::_1 > >, 
+                                                 search_colors::Gray>,
+                                              typename VisitorOps::template back_edge<mpl::_2, Graph, mpl::first<mpl::_1> >,
+                                              typename VisitorOps::template forward_or_cross_edge<mpl::_2, Graph, mpl::first<mpl::_1> > >,  // Black
+                                     mpl::second<mpl::_1> > > 
+                 >::type after_outedges;
+                 
+    // leave vertex, and done!
+    typedef mpl::pair<typename VisitorOps::template finish_vertex<Vertex, Graph, typename mpl::first<after_outedges>::type >::type,
+                      typename search_color_map_ops::template set_color<Vertex, search_colors::Black, typename mpl::second<after_outedges>::type>::type> type;
+};
+
+// requires IncidenceGraph, VertexListGraph
+template<typename Graph, typename VisitorOps, typename VisitorState,
+         typename FirstVertex = typename mpl::front<typename mpl_graph::vertices<Graph>::type>::type,
+         typename ColorState = create_search_color_map::type>
+struct depth_first_search_all : // visit first then rest
+    mpl::fold<typename mpl_graph::vertices<Graph>::type,
+              typename depth_first_search<Graph, 
+                                          VisitorOps, VisitorState, 
+                                          FirstVertex, 
+                                          ColorState>::type, 
+              mpl::if_<boost::is_same<search_color_map_ops::get_color<mpl::_2, mpl::second<mpl::_1> >,
+                                      search_colors::White>, // visit any yet unvisited
+                       depth_first_search<Graph,
+                                 VisitorOps, mpl::first<mpl::_1>,
+                                 mpl::_2,
+                                 mpl::second<mpl::_1> >,
+                       mpl::_1> >   
+{};
+
+} // namespace mpl_graph
+} // namespace msm
+} // namespace boost
+
+
+#endif // BOOST_MSM_MPL_GRAPH_DEPTH_FIRST_SEARCH_HPP_INCLUDED

test/external/boost/msm/mpl_graph/detail/adjacency_list_graph.ipp

@@ -0,0 +1,128 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_DETAIL_ADJACENCY_LIST_GRAPH_IPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_DETAIL_ADJACENCY_LIST_GRAPH_IPP_INCLUDED
+
+// implementation of a graph declared in adjacency list format
+// sequence< pair< source_vertex, sequence< pair<edge, target_vertex> > > >
+
+#include <boost/msm/mpl_graph/mpl_utils.hpp>
+#include <boost/msm/mpl_graph/detail/incidence_list_graph.ipp>
+
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/inserter.hpp>
+#include <boost/mpl/map.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/pair.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/push_back.hpp>
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+namespace detail {
+    
+// tag identifying graph implementation as adjacency list (not defined)
+struct adjacency_list_tag;
+
+// outs map is really just the same data with the sequences turned into maps
+// it might make sense to make another adjacency_map implementation for that case
+template<typename AdjacencyList>
+struct produce_al_outs_map :
+    mpl::reverse_fold<AdjacencyList,
+              mpl::map<>,
+              mpl::insert<mpl::_1,
+                          mpl::pair<mpl::first<mpl::_2>, mpl_utils::as_map<mpl::second<mpl::_2> > > > >
+{};
+                                    
+// Edge->Target map for a Source for out_*, degree
+template<typename Source, typename GraphData>
+struct produce_out_map<adjacency_list_tag, Source, GraphData> : 
+    mpl::at<typename produce_al_outs_map<GraphData>::type, Source>
+{};
+
+template<typename InsMap, typename Source, typename Adjacencies>
+struct produce_in_adjacencies :
+    mpl::reverse_fold<Adjacencies,
+              InsMap,
+              mpl::insert<mpl::_1,
+                          mpl::pair<mpl::second<mpl::_2>,
+                                    mpl::insert<mpl_utils::at_or_default<mpl::_1, mpl::second<mpl::_2>, mpl::map<> >,
+                                                mpl::pair<mpl::first<mpl::_2>, Source> > > > >
+{};
+    
+template<typename AdjacencyList>
+struct produce_al_ins_map :
+    mpl::reverse_fold<AdjacencyList,
+              mpl::map<>,
+              produce_in_adjacencies<mpl::_1, mpl::first<mpl::_2>, mpl::second<mpl::_2> > >
+{};
+
+// Edge->Source map for a Target for in_*, degree
+template<typename Target, typename GraphData>
+struct produce_in_map<adjacency_list_tag, Target, GraphData> :
+    mpl::at<typename produce_al_ins_map<GraphData>::type, Target>
+{};
+
+// for everything else to do with edges, 
+// just produce an incidence list and forward to that graph implementation
+// (produce_out_map could, and produce_in_map probably should, be implemented this way too)
+template<typename Incidences, typename Source, typename Adjacencies>
+struct produce_adjacencies_incidences : // adjacencies' 
+    mpl::reverse_fold<Adjacencies,
+              Incidences,
+              mpl::push_back<mpl::_1,
+                             mpl::vector3<mpl::first<mpl::_2>, Source, mpl::second<mpl::_2> > > >
+{};
+    
+template<typename AdjacencyList>
+struct produce_incidence_list_from_adjacency_list :
+    mpl::reverse_fold<AdjacencyList,
+              mpl::vector<>,
+              produce_adjacencies_incidences<mpl::_1, mpl::first<mpl::_2>, mpl::second<mpl::_2> > >
+{};
+
+
+// Edge->pair<Source,Target> map for source, target
+template<typename GraphData>
+struct produce_edge_st_map<adjacency_list_tag, GraphData> :
+    produce_edge_st_map<incidence_list_tag,
+                        typename produce_incidence_list_from_adjacency_list<GraphData>::type>
+{};
+             
+
+// adjacency list supports zero-degree vertices, which incidence list does not
+template<typename VertexSet, typename Adjacencies>
+struct insert_adjacencies_targets : // adjacencies' 
+    mpl::reverse_fold<Adjacencies,
+              VertexSet,
+              mpl::insert<mpl::_1, mpl::second<mpl::_2> > >
+{};
+
+template<typename GraphData>
+struct produce_vertex_set<adjacency_list_tag, GraphData> :
+    mpl::reverse_fold<GraphData,
+              mpl::set<>,
+              insert_adjacencies_targets<mpl::insert<mpl::_1, mpl::first<mpl::_2> >,
+                                         mpl::second<mpl::_2> > >
+{};
+                                        
+
+// Edge set for EdgeListGraph
+template<typename GraphData>
+struct produce_edge_set<adjacency_list_tag, GraphData> :
+    produce_edge_set<incidence_list_tag,
+                     typename produce_incidence_list_from_adjacency_list<GraphData>::type>
+{};
+
+
+} // namespaces   
+}
+}
+}
+
+#endif // BOOST_MSM_MPL_GRAPH_DETAIL_ADJACENCY_LIST_GRAPH_IPP_INCLUDED
+

test/external/boost/msm/mpl_graph/detail/graph_implementation_interface.ipp

@@ -0,0 +1,42 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_DETAIL_GRAPH_IMPLEMENTATION_INTERFACE_IPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_DETAIL_GRAPH_IMPLEMENTATION_INTERFACE_IPP_INCLUDED
+
+// forward definitions of the producer metafunctions that need to be specialized for
+// each graph representation
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+namespace detail {
+    
+    // Edge->Target map for a Source for out_*, degree
+    template<typename RepresentationTag, typename Source, typename GraphData>
+    struct produce_out_map;
+
+    // Edge->Source map for a Target for in_*, degree
+    template<typename RepresentationTag, typename Target, typename GraphData>
+    struct produce_in_map;
+    
+    // Edge->pair<Source,Target> map for source, target
+    template<typename RepresentationTag, typename GraphData>
+    struct produce_edge_st_map;
+    
+    // Vertex set for VertexListGraph
+    template<typename RepresentationTag, typename GraphData>
+    struct produce_vertex_set;
+    
+    // Edge set for EdgeListGraph
+    template<typename RepresentationTag, typename GraphData>
+    struct produce_edge_set;
+
+} // namespaces   
+}
+}
+}
+
+#endif // BOOST_MSM_MPL_GRAPH_DETAIL_GRAPH_IMPLEMENTATION_INTERFACE_IPP_INCLUDED
+

test/external/boost/msm/mpl_graph/detail/incidence_list_graph.ipp

@@ -0,0 +1,106 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_DETAIL_INCIDENCE_LIST_GRAPH_IPP_INCLUDED
+
+#define BOOST_MSM_MPL_GRAPH_DETAIL_INCIDENCE_LIST_GRAPH_IPP_INCLUDED
+
+// these metafunctions provide the metadata structures needed by the public interface 
+// in mpl_graph.hpp
+
+#include <boost/mpl/map.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/back.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/erase_key.hpp>
+#include <boost/mpl/has_key.hpp>
+#include <boost/mpl/inserter.hpp>
+#include <boost/mpl/back_inserter.hpp>
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/pair.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/filter_view.hpp>
+#include <boost/mpl/transform_view.hpp>
+#include <boost/mpl/equal.hpp>
+#include <boost/type_traits.hpp>
+
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+namespace detail {
+
+// tag to identify this graph implementation (not defined)
+struct incidence_list_tag;
+    
+// clarifiers
+template<typename EST> struct fetch_edge : 
+    mpl::front<EST> {};
+template<typename EST> struct fetch_source : 
+    mpl::deref<typename mpl::next<typename mpl::begin<EST>::type>::type> {};
+template<typename EST> struct fetch_target : 
+    mpl::back<EST> {};
+
+// Edge->Target map for an Source for out_*, adjacent_vertices
+template<typename Source, typename ESTSequence>
+struct produce_out_map<incidence_list_tag, Source, ESTSequence> :
+    mpl::fold<typename mpl::filter_view<ESTSequence, boost::is_same<fetch_source<mpl::_1>,Source> >::type,
+         mpl::map<>,
+         mpl::insert<mpl::_1,mpl::pair<fetch_edge<mpl::_2>,fetch_target<mpl::_2> > > >
+{};
+
+// Edge->Source map for a Target for in_*, degree
+template<typename Target, typename ESTSequence>
+struct produce_in_map<incidence_list_tag, Target, ESTSequence> :
+    mpl::fold<typename mpl::filter_view<ESTSequence, 
+                                        boost::is_same<fetch_target<mpl::_1>,Target> >::type,
+         mpl::map<>,
+         mpl::insert<mpl::_1,mpl::pair<fetch_edge<mpl::_2>,fetch_source<mpl::_2> > > >
+
+{};
+// Edge->pair<Source,Target> map for source, target
+template<typename ESTSequence>
+struct produce_edge_st_map<incidence_list_tag, ESTSequence> :
+    mpl::fold<ESTSequence,
+         mpl::map<>,
+         mpl::insert<mpl::_1,mpl::pair<fetch_edge<mpl::_2>,
+                        mpl::pair<fetch_source<mpl::_2>, 
+                             fetch_target<mpl::_2> > > > >
+{};
+// Vertex set for VertexListGraph
+template<typename ESTSequence>
+struct produce_vertex_set<incidence_list_tag, ESTSequence> :
+    mpl::fold<ESTSequence,
+         typename mpl::fold<ESTSequence,
+                       mpl::set<>,
+                       mpl::insert<mpl::_1,fetch_target<mpl::_2> >
+                       >::type,
+         mpl::insert<mpl::_1, fetch_source<mpl::_2> > >
+{};
+// Edge set for EdgeListGraph
+template<typename ESTSequence>
+struct produce_edge_set<incidence_list_tag, ESTSequence> :
+    mpl::fold<ESTSequence,
+        mpl::set<>,
+        mpl::insert<mpl::_1,fetch_edge<mpl::_2> > >
+{};
+}
+}
+}
+}
+
+#endif // BOOST_MSM_MPL_GRAPH_DETAIL_INCIDENCE_LIST_GRAPH_IPP_INCLUDED

test/external/boost/msm/mpl_graph/incidence_list_graph.hpp

@@ -0,0 +1,34 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_INCIDENCE_LIST_GRAPH_HPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_INCIDENCE_LIST_GRAPH_HPP_INCLUDED
+
+// graph implementation based on a an mpl sequence of sequences <Edge,Source,Target> 
+
+// incidence_list_graph labels such a sequence as manipulable by the metafunctions
+// in the corresponding implementation header detail/incidence_list_graph.ipp
+// to produce the metadata structures needed by mpl_graph.hpp 
+
+// the public interface
+#include <boost/msm/mpl_graph/mpl_graph.hpp>
+
+// the implementation
+#include <boost/msm/mpl_graph/detail/incidence_list_graph.ipp>
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+   
+template<typename EdgeSequence>
+struct incidence_list_graph {
+    typedef detail::incidence_list_tag representation;
+    typedef EdgeSequence data;
+};
+
+}
+}
+}
+
+#endif // BOOST_MSM_MPL_GRAPH_INCIDENCE_LIST_GRAPH_HPP_INCLUDED

test/external/boost/msm/mpl_graph/mpl_graph.hpp

@@ -0,0 +1,114 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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)
+
+// mpl_graph - defines a metadata implementation of the BGL immutable graph concepts
+
+// (c) 2008 Gordon Woodhull 
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSEmpl::_1_0.txt or copy at
+// http://www.boost.org/LICENSEmpl::_1_0.txt)
+
+#ifndef BOOST_MSM_MPL_GRAPH_MPL_GRAPH_HPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_MPL_GRAPH_HPP_INCLUDED
+
+#include <boost/msm/mpl_graph/detail/graph_implementation_interface.ipp>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/pair.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/back_inserter.hpp>
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+
+// Boost Graph concepts, MPL style
+
+// The metafunctions of the public interface rely 
+// metafunctions in the graph implementation to transform the input 
+// into the maps which are required to deliver results.  Since the
+// maps are produced lazily and are memoized, all of the graph
+// concepts can be supported with no cost until they are actually
+// used.
+
+// Each of these dispatch to the correct producer metafunctions based
+// on the representation inner type tag
+
+
+
+// IncidenceGraph
+template<typename Edge, typename Graph>
+struct source : 
+    mpl::first<typename mpl::at<typename detail::produce_edge_st_map<typename Graph::representation, typename Graph::data>::type,Edge>::type> 
+{};
+template<typename Edge, typename Graph>
+struct target : 
+    mpl::second<typename mpl::at<typename detail::produce_edge_st_map<typename Graph::representation, typename Graph::data>::type,Edge>::type> 
+{};
+template<typename Vertex, typename Graph>
+struct out_edges :
+    mpl::fold<typename detail::produce_out_map<typename Graph::representation, Vertex, typename Graph::data>::type,
+         mpl::vector<>,
+         mpl::push_back<mpl::_1, mpl::first<mpl::_2> > >
+{};
+template<typename Vertex, typename Graph>
+struct out_degree : 
+    mpl::size<typename out_edges<Vertex, Graph>::type>
+{};
+
+// BidirectionalGraph
+template<typename Vertex, typename Graph>
+struct in_edges :
+    mpl::fold<typename detail::produce_in_map<typename Graph::representation, Vertex, typename Graph::data>::type,
+         mpl::vector<>,
+         mpl::push_back<mpl::_1, mpl::first<mpl::_2> > >
+{};
+template<typename Vertex, typename Graph>
+struct in_degree :
+    mpl::size<typename in_edges<Vertex, Graph>::type>
+{};
+template<typename Vertex, typename Graph>
+struct degree :
+    mpl::plus<typename out_degree<Vertex, Graph>::type,typename in_degree<Vertex, Graph>::type>
+{};
+
+// AdjacencyGraph 
+template<typename Vertex, typename Graph>
+struct adjacent_vertices :
+    mpl::transform<typename detail::produce_out_map<typename Graph::representation, Vertex, typename Graph::data>::type,
+              mpl::second<mpl::_1>,
+              mpl::back_inserter<mpl::vector<> > >
+{};
+
+// VertexListGraph
+template<typename Graph>
+struct vertices :
+    detail::produce_vertex_set<typename Graph::representation, typename Graph::data>
+{};
+template<typename Graph>
+struct num_vertices :
+    mpl::size<typename vertices<Graph>::type>
+{};
+
+// EdgeListGraph
+template<typename Graph>
+struct edges :
+    detail::produce_edge_set<typename Graph::representation, typename Graph::data>
+{};
+template<typename Graph>
+struct num_edges :
+    mpl::size<typename edges<Graph>::type>
+{};
+// source and target are defined in IncidenceGraph
+
+} // mpl_graph
+} // msm
+} // boost
+
+#endif // BOOST_MSM_MPL_GRAPH_MPL_GRAPH_HPP_INCLUDED

test/external/boost/msm/mpl_graph/mpl_utils.hpp

@@ -0,0 +1,62 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_MPL_UTILS_HPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_MPL_UTILS_HPP_INCLUDED
+
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/map.hpp>
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/has_key.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/and.hpp>
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+namespace mpl_utils {
+    
+// This is a grab bag of little metafunctions I expect already
+// exist under some name I haven't looked for
+
+// I figure there are probably better ways to do all of these things,
+// but for now I'll just write some utilities to isolate my ignorance
+
+template<typename Seq>
+struct as_map :
+    mpl::fold<Seq, 
+              mpl::map<>, 
+              mpl::insert<mpl::_1, mpl::_2> >
+{};
+template<typename Seq>
+struct as_set :
+    mpl::fold<Seq, 
+              mpl::set<>, 
+              mpl::insert<mpl::_1, mpl::_2> >
+{};
+
+template<typename AssocSeq, typename Key, typename Default>
+struct at_or_default :
+    mpl::if_<typename mpl::has_key<AssocSeq, Key>::type,
+             typename mpl::at<AssocSeq, Key>::type,
+             Default>
+{};
+
+template<typename Seq1, typename Seq2>
+struct set_equal :
+    mpl::fold<Seq2,
+              mpl::true_,
+              mpl::and_<mpl::_1, 
+                        mpl::has_key<typename as_set<Seq1>::type, 
+                                     mpl::_2 > > >
+{};
+                                       
+}
+}
+}
+}              
+
+#endif // BOOST_MSM_MPL_GRAPH_MPL_UTILS_HPP_INCLUDED

test/external/boost/msm/mpl_graph/search_colors.hpp

@@ -0,0 +1,39 @@
+// Copyright 2008-2010 Gordon Woodhull
+// 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_MPL_GRAPH_SEARCH_COLORS_HPP_INCLUDED
+#define BOOST_MSM_MPL_GRAPH_SEARCH_COLORS_HPP_INCLUDED
+
+namespace boost {
+namespace msm {
+namespace mpl_graph {
+
+namespace search_colors {
+    struct White {};
+    struct Gray {};
+    struct Black {};
+}
+
+struct create_search_color_map : mpl::map<> {};
+
+struct search_color_map_ops {
+    template<typename Node, typename Color, typename State>
+    struct set_color :
+        mpl::insert<State, mpl::pair<Node, Color> >
+    {};
+    template<typename Node, typename State>
+    struct get_color :
+        mpl::if_<mpl::has_key<State, Node>,
+                 mpl::at<State, Node>,
+                 search_colors::White>
+    {};
+};
+
+
+} // namespace mpl_graph
+} // namespace msm
+} // namespace boost
+
+
+#endif // BOOST_MSM_MPL_GRAPH_SEARCH_COLORS_HPP_INCLUDED

test/external/boost/msm/msm_grammar.hpp

@@ -0,0 +1,46 @@
+// 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_GRAMMAR_H
+#define BOOST_MSM_GRAMMAR_H
+
+#include <boost/msm/common.hpp>
+
+
+namespace boost { namespace msm
+{
+// base grammar for all of msm's proto-based grammars
+struct basic_grammar : proto::_
+{};
+
+// Forward-declare an expression wrapper
+template<typename Expr>
+struct msm_terminal;
+
+struct msm_domain
+    : proto::domain< proto::generator<msm_terminal>, basic_grammar >
+{};
+
+template<typename Expr>
+struct msm_terminal
+    : proto::extends<Expr, msm_terminal<Expr>, msm_domain>
+{
+    typedef
+        proto::extends<Expr, msm_terminal<Expr>, msm_domain>
+        base_type;
+    // Needs a constructor
+    msm_terminal(Expr const &e = Expr())
+        : base_type(e)
+    {}
+};
+
+} } // boost::msm
+#endif //BOOST_MSM_GRAMMAR_H
+

test/external/boost/msm/proto_config.hpp

@@ -0,0 +1,16 @@
+// 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_PROTO_CONFIG_H
+#define BOOST_MSM_PROTO_CONFIG_H
+
+#include <boost/proto/proto_fwd.hpp>
+
+#endif //BOOST_MSM_PROTO_CONFIG_H

test/external/boost/msm/row_tags.hpp

@@ -0,0 +1,53 @@
+// 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_ROW_TAGS_H
+#define BOOST_MSM_ROW_TAGS_H
+
+
+
+namespace boost { namespace msm
+{
+//tags
+struct a_row_tag {};
+struct g_row_tag {};
+struct _row_tag {};
+struct row_tag {};
+// tags for internal transitions
+struct a_irow_tag {};
+struct g_irow_tag {};
+struct _irow_tag {};
+struct irow_tag {};
+// tags for transitions internal to state machines (not using any substate)
+struct sm_a_i_row_tag {};
+struct sm_g_i_row_tag {};
+struct sm__i_row_tag {};
+struct sm_i_row_tag {};
+
+// flags used internally to handle terminate / interrupt states
+struct TerminateFlag 
+{
+    typedef int non_forwarding_flag;
+    typedef int event_blocking_flag;
+};
+struct InterruptedFlag
+{
+    typedef int non_forwarding_flag;
+    typedef int event_blocking_flag;
+};
+template <class EndEvent>
+struct EndInterruptFlag
+{
+    typedef int non_forwarding_flag;
+};
+
+} } // boost::msm
+#endif //BOOST_MSM_ROW_TAGS_H
+