?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/back.zip
???????
PK �!\/(�/ no_fsm_check.hppnu �[��� // 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 PK �!\���R� � tools.hppnu �[��� // 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 PK �!\O�C�� �� state_machine.hppnu �[��� // 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_STATEMACHINE_H #define BOOST_MSM_BACK_STATEMACHINE_H #include <exception> #include <vector> #include <functional> #include <numeric> #include <utility> #include <boost/core/no_exceptions_support.hpp> #include <boost/mpl/contains.hpp> #include <boost/mpl/deref.hpp> #include <boost/mpl/assert.hpp> #include <boost/fusion/container/vector/convert.hpp> #include <boost/fusion/include/as_vector.hpp> #include <boost/fusion/include/as_set.hpp> #include <boost/fusion/container/set.hpp> #include <boost/fusion/include/set.hpp> #include <boost/fusion/include/set_fwd.hpp> #include <boost/fusion/include/mpl.hpp> #include <boost/fusion/sequence/intrinsic/at_key.hpp> #include <boost/fusion/include/at_key.hpp> #include <boost/fusion/algorithm/iteration/for_each.hpp> #include <boost/fusion/include/for_each.hpp> #include <boost/assert.hpp> #include <boost/ref.hpp> #include <boost/type_traits.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_convertible.hpp> #include <boost/bind/bind.hpp> #include <boost/function.hpp> #ifndef BOOST_NO_RTTI #include <boost/any.hpp> #endif #include <boost/serialization/base_object.hpp> #include <boost/parameter.hpp> #include <boost/msm/active_state_switching_policies.hpp> #include <boost/msm/row_tags.hpp> #include <boost/msm/msm_grammar.hpp> #include <boost/msm/back/fold_to_list.hpp> #include <boost/msm/back/metafunctions.hpp> #include <boost/msm/back/history_policies.hpp> #include <boost/msm/back/common_types.hpp> #include <boost/msm/back/args.hpp> #include <boost/msm/back/default_compile_policy.hpp> #include <boost/msm/back/dispatch_table.hpp> #include <boost/msm/back/no_fsm_check.hpp> #include <boost/msm/back/queue_container_deque.hpp> BOOST_MPL_HAS_XXX_TRAIT_DEF(accept_sig) BOOST_MPL_HAS_XXX_TRAIT_DEF(no_automatic_create) BOOST_MPL_HAS_XXX_TRAIT_DEF(non_forwarding_flag) BOOST_MPL_HAS_XXX_TRAIT_DEF(direct_entry) BOOST_MPL_HAS_XXX_TRAIT_DEF(initial_event) BOOST_MPL_HAS_XXX_TRAIT_DEF(final_event) BOOST_MPL_HAS_XXX_TRAIT_DEF(do_serialize) BOOST_MPL_HAS_XXX_TRAIT_DEF(history_policy) BOOST_MPL_HAS_XXX_TRAIT_DEF(fsm_check) BOOST_MPL_HAS_XXX_TRAIT_DEF(compile_policy) BOOST_MPL_HAS_XXX_TRAIT_DEF(queue_container_policy) BOOST_MPL_HAS_XXX_TRAIT_DEF(using_declared_table) BOOST_MPL_HAS_XXX_TRAIT_DEF(event_queue_before_deferred_queue) #ifndef BOOST_MSM_CONSTRUCTOR_ARG_SIZE #define BOOST_MSM_CONSTRUCTOR_ARG_SIZE 5 // default max number of arguments for constructors #endif namespace boost { namespace msm { namespace back { // event used internally for wrapping a direct entry template <class StateType,class Event> struct direct_entry_event { typedef int direct_entry; typedef StateType active_state; typedef Event contained_event; direct_entry_event(Event const& evt):m_event(evt){} Event const& m_event; }; // This declares the statically-initialized dispatch_table instance. template <class Fsm,class Stt, class Event,class CompilePolicy> const boost::msm::back::dispatch_table<Fsm,Stt, Event,CompilePolicy> dispatch_table<Fsm,Stt, Event,CompilePolicy>::instance; BOOST_PARAMETER_TEMPLATE_KEYWORD(front_end) BOOST_PARAMETER_TEMPLATE_KEYWORD(history_policy) BOOST_PARAMETER_TEMPLATE_KEYWORD(compile_policy) BOOST_PARAMETER_TEMPLATE_KEYWORD(fsm_check_policy) BOOST_PARAMETER_TEMPLATE_KEYWORD(queue_container_policy) typedef ::boost::parameter::parameters< ::boost::parameter::required< ::boost::msm::back::tag::front_end > , ::boost::parameter::optional< ::boost::parameter::deduced< ::boost::msm::back::tag::history_policy>, has_history_policy< ::boost::mpl::_ > > , ::boost::parameter::optional< ::boost::parameter::deduced< ::boost::msm::back::tag::compile_policy>, has_compile_policy< ::boost::mpl::_ > > , ::boost::parameter::optional< ::boost::parameter::deduced< ::boost::msm::back::tag::fsm_check_policy>, has_fsm_check< ::boost::mpl::_ > > , ::boost::parameter::optional< ::boost::parameter::deduced< ::boost::msm::back::tag::queue_container_policy>, has_queue_container_policy< ::boost::mpl::_ > > > state_machine_signature; // just here to disable use of proto when not needed template <class T, class F,class Enable=void> struct make_euml_terminal; template <class T,class F> struct make_euml_terminal<T,F,typename ::boost::disable_if<has_using_declared_table<F> >::type> {}; template <class T,class F> struct make_euml_terminal<T,F,typename ::boost::enable_if<has_using_declared_table<F> >::type> : public proto::extends<typename proto::terminal< boost::msm::state_tag>::type, T, boost::msm::state_domain> {}; // library-containing class for state machines. Pass the actual FSM class as // the Concrete parameter. // A0=Derived,A1=NoHistory,A2=CompilePolicy,A3=FsmCheckPolicy > template < class A0 , class A1 = parameter::void_ , class A2 = parameter::void_ , class A3 = parameter::void_ , class A4 = parameter::void_ > class state_machine : //public Derived public ::boost::parameter::binding< typename state_machine_signature::bind<A0,A1,A2,A3,A4>::type, ::boost::msm::back::tag::front_end >::type , public make_euml_terminal<state_machine<A0,A1,A2,A3,A4>, typename ::boost::parameter::binding< typename state_machine_signature::bind<A0,A1,A2,A3,A4>::type, ::boost::msm::back::tag::front_end >::type > { public: // Create ArgumentPack typedef typename state_machine_signature::bind<A0,A1,A2,A3,A4>::type state_machine_args; // Extract first logical parameter. typedef typename ::boost::parameter::binding< state_machine_args, ::boost::msm::back::tag::front_end>::type Derived; typedef typename ::boost::parameter::binding< state_machine_args, ::boost::msm::back::tag::history_policy, NoHistory >::type HistoryPolicy; typedef typename ::boost::parameter::binding< state_machine_args, ::boost::msm::back::tag::compile_policy, favor_runtime_speed >::type CompilePolicy; typedef typename ::boost::parameter::binding< state_machine_args, ::boost::msm::back::tag::fsm_check_policy, no_fsm_check >::type FsmCheckPolicy; typedef typename ::boost::parameter::binding< state_machine_args, ::boost::msm::back::tag::queue_container_policy, queue_container_deque >::type QueueContainerPolicy; private: typedef boost::msm::back::state_machine< A0,A1,A2,A3,A4> library_sm; typedef ::boost::function< execute_return ()> transition_fct; typedef ::boost::function< execute_return () > deferred_fct; typedef typename QueueContainerPolicy:: template In< std::pair<deferred_fct,char> >::type deferred_events_queue_t; typedef typename QueueContainerPolicy:: template In<transition_fct>::type events_queue_t; typedef typename boost::mpl::eval_if< typename is_active_state_switch_policy<Derived>::type, get_active_state_switch_policy<Derived>, // default ::boost::mpl::identity<active_state_switch_after_entry> >::type active_state_switching; typedef bool (*flag_handler)(library_sm const&); // all state machines are friend with each other to allow embedding any of them in another fsm template <class ,class , class, class, class > friend class boost::msm::back::state_machine; // helper to add, if needed, visitors to all states // version without visitors template <class StateType,class Enable=void> struct visitor_fct_helper { public: visitor_fct_helper(){} void fill_visitors(int) { } template <class FCT> void insert(int,FCT) { } template <class VISITOR> void execute(int,VISITOR) { } }; // version with visitors template <class StateType> struct visitor_fct_helper<StateType,typename ::boost::enable_if<has_accept_sig<StateType> >::type> { public: visitor_fct_helper():m_state_visitors(){} void fill_visitors(int number_of_states) { m_state_visitors.resize(number_of_states); } template <class FCT> void insert(int index,FCT fct) { m_state_visitors[index]=fct; } void execute(int index) { m_state_visitors[index](); } #define MSM_VISITOR_HELPER_EXECUTE_SUB(z, n, unused) ARG ## n vis ## n #define MSM_VISITOR_HELPER_EXECUTE(z, n, unused) \ template <BOOST_PP_ENUM_PARAMS(n, class ARG)> \ void execute(int index BOOST_PP_COMMA_IF(n) \ BOOST_PP_ENUM(n, MSM_VISITOR_HELPER_EXECUTE_SUB, ~ ) ) \ { \ m_state_visitors[index](BOOST_PP_ENUM_PARAMS(n,vis)); \ } BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_ADD(BOOST_MSM_VISITOR_ARG_SIZE,1), MSM_VISITOR_HELPER_EXECUTE, ~) #undef MSM_VISITOR_HELPER_EXECUTE #undef MSM_VISITOR_HELPER_EXECUTE_SUB private: typedef typename StateType::accept_sig::type visitor_fct; typedef std::vector<visitor_fct> visitors; visitors m_state_visitors; }; template <class StateType,class Enable=int> struct deferred_msg_queue_helper { void clear(){} }; template <class StateType> struct deferred_msg_queue_helper<StateType, typename ::boost::enable_if< typename ::boost::msm::back::has_fsm_deferred_events<StateType>::type,int >::type> { public: deferred_msg_queue_helper():m_deferred_events_queue(),m_cur_seq(0){} void clear() { m_deferred_events_queue.clear(); } deferred_events_queue_t m_deferred_events_queue; char m_cur_seq; }; public: // tags typedef int composite_tag; // in case someone needs to know typedef HistoryPolicy history_policy; struct InitEvent { }; struct ExitEvent { }; // flag handling struct Flag_AND { typedef std::logical_and<bool> type; }; struct Flag_OR { typedef std::logical_or<bool> type; }; typedef typename Derived::BaseAllStates BaseState; typedef Derived ConcreteSM; // if the front-end fsm provides an initial_event typedef, replace InitEvent by this one typedef typename ::boost::mpl::eval_if< typename has_initial_event<Derived>::type, get_initial_event<Derived>, ::boost::mpl::identity<InitEvent> >::type fsm_initial_event; // if the front-end fsm provides an exit_event typedef, replace ExitEvent by this one typedef typename ::boost::mpl::eval_if< typename has_final_event<Derived>::type, get_final_event<Derived>, ::boost::mpl::identity<ExitEvent> >::type fsm_final_event; template <class ExitPoint> struct exit_pt : public ExitPoint { // tags typedef ExitPoint wrapped_exit; typedef int pseudo_exit; typedef library_sm owner; typedef int no_automatic_create; typedef typename ExitPoint::event Event; typedef ::boost::function<execute_return (Event const&)> forwarding_function; // forward event to the higher-level FSM template <class ForwardEvent> void forward_event(ForwardEvent const& incomingEvent) { // use helper to forward or not ForwardHelper< ::boost::is_convertible<ForwardEvent,Event>::value>::helper(incomingEvent,m_forward); } void set_forward_fct(::boost::function<execute_return (Event const&)> fct) { m_forward = fct; } exit_pt():m_forward(){} // by assignments, we keep our forwarding functor unchanged as our containing SM did not change template <class RHS> exit_pt(RHS&):m_forward(){} exit_pt<ExitPoint>& operator= (const exit_pt<ExitPoint>& ) { return *this; } private: forwarding_function m_forward; // using partial specialization instead of enable_if because of VC8 bug template <bool OwnEvent, int Dummy=0> struct ForwardHelper { template <class ForwardEvent> static void helper(ForwardEvent const& ,forwarding_function& ) { // Not our event, assert BOOST_ASSERT(false); } }; template <int Dummy> struct ForwardHelper<true,Dummy> { template <class ForwardEvent> static void helper(ForwardEvent const& incomingEvent,forwarding_function& forward_fct) { // call if handler set, if not, this state is simply a terminate state if (forward_fct) forward_fct(incomingEvent); } }; }; template <class EntryPoint> struct entry_pt : public EntryPoint { // tags typedef EntryPoint wrapped_entry; typedef int pseudo_entry; typedef library_sm owner; typedef int no_automatic_create; }; template <class EntryPoint> struct direct : public EntryPoint { // tags typedef EntryPoint wrapped_entry; typedef int explicit_entry_state; typedef library_sm owner; typedef int no_automatic_create; }; typedef typename get_number_of_regions<typename Derived::initial_state>::type nr_regions; // Template used to form rows in the transition table template< typename ROW > struct row_ { //typedef typename ROW::Source T1; typedef typename make_entry<typename ROW::Source,library_sm>::type T1; typedef typename make_exit<typename ROW::Target,library_sm>::type T2; typedef typename ROW::Evt transition_event; // if the source is an exit pseudo state, then // current_state_type becomes the result of get_owner // meaning the containing SM from which the exit occurs typedef typename ::boost::mpl::eval_if< typename has_pseudo_exit<T1>::type, get_owner<T1,library_sm>, ::boost::mpl::identity<typename ROW::Source> >::type current_state_type; // if Target is a sequence, then we have a fork and expect a sequence of explicit_entry // else if Target is an explicit_entry, next_state_type becomes the result of get_owner // meaning the containing SM if the row is "outside" the containing SM or else the explicit_entry state itself typedef typename ::boost::mpl::eval_if< typename ::boost::mpl::is_sequence<T2>::type, get_fork_owner<T2,library_sm>, ::boost::mpl::eval_if< typename has_no_automatic_create<T2>::type, get_owner<T2,library_sm>, ::boost::mpl::identity<T2> > >::type next_state_type; // if a guard condition is here, call it to check that the event is accepted static bool check_guard(library_sm& fsm,transition_event const& evt) { if ( ROW::guard_call(fsm,evt, ::boost::fusion::at_key<current_state_type>(fsm.m_substate_list), ::boost::fusion::at_key<next_state_type>(fsm.m_substate_list), fsm.m_substate_list ) ) return true; return false; } // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int region_index, int state, transition_event const& evt) { BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value)); BOOST_STATIC_CONSTANT(int, next_state = (get_state_id<stt,next_state_type>::type::value)); BOOST_ASSERT(state == (current_state)); // if T1 is an exit pseudo state, then take the transition only if the pseudo exit state is active if (has_pseudo_exit<T1>::type::value && !is_exit_state_active<T1,get_owner<T1,library_sm> >(fsm)) { return HANDLED_FALSE; } if (!check_guard(fsm,evt)) { // guard rejected the event, we stay in the current one return HANDLED_GUARD_REJECT; } fsm.m_states[region_index] = active_state_switching::after_guard(current_state,next_state); // the guard condition has already been checked execute_exit<current_state_type> (::boost::fusion::at_key<current_state_type>(fsm.m_substate_list),evt,fsm); fsm.m_states[region_index] = active_state_switching::after_exit(current_state,next_state); // then call the action method HandledEnum res = ROW::action_call(fsm,evt, ::boost::fusion::at_key<current_state_type>(fsm.m_substate_list), ::boost::fusion::at_key<next_state_type>(fsm.m_substate_list), fsm.m_substate_list); fsm.m_states[region_index] = active_state_switching::after_action(current_state,next_state); // and finally the entry method of the new current state convert_event_and_execute_entry<next_state_type,T2> (::boost::fusion::at_key<next_state_type>(fsm.m_substate_list),evt,fsm); fsm.m_states[region_index] = active_state_switching::after_entry(current_state,next_state); return res; } }; // row having only a guard condition template< typename ROW > struct g_row_ { //typedef typename ROW::Source T1; typedef typename make_entry<typename ROW::Source,library_sm>::type T1; typedef typename make_exit<typename ROW::Target,library_sm>::type T2; typedef typename ROW::Evt transition_event; // if the source is an exit pseudo state, then // current_state_type becomes the result of get_owner // meaning the containing SM from which the exit occurs typedef typename ::boost::mpl::eval_if< typename has_pseudo_exit<T1>::type, get_owner<T1,library_sm>, ::boost::mpl::identity<typename ROW::Source> >::type current_state_type; // if Target is a sequence, then we have a fork and expect a sequence of explicit_entry // else if Target is an explicit_entry, next_state_type becomes the result of get_owner // meaning the containing SM if the row is "outside" the containing SM or else the explicit_entry state itself typedef typename ::boost::mpl::eval_if< typename ::boost::mpl::is_sequence<T2>::type, get_fork_owner<T2,library_sm>, ::boost::mpl::eval_if< typename has_no_automatic_create<T2>::type, get_owner<T2,library_sm>, ::boost::mpl::identity<T2> > >::type next_state_type; // if a guard condition is defined, call it to check that the event is accepted static bool check_guard(library_sm& fsm,transition_event const& evt) { if ( ROW::guard_call(fsm,evt, ::boost::fusion::at_key<current_state_type>(fsm.m_substate_list), ::boost::fusion::at_key<next_state_type>(fsm.m_substate_list), fsm.m_substate_list )) return true; return false; } // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int region_index, int state, transition_event const& evt) { BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value)); BOOST_STATIC_CONSTANT(int, next_state = (get_state_id<stt,next_state_type>::type::value)); BOOST_ASSERT(state == (current_state)); // if T1 is an exit pseudo state, then take the transition only if the pseudo exit state is active if (has_pseudo_exit<T1>::type::value && !is_exit_state_active<T1,get_owner<T1,library_sm> >(fsm)) { return HANDLED_FALSE; } if (!check_guard(fsm,evt)) { // guard rejected the event, we stay in the current one return HANDLED_GUARD_REJECT; } fsm.m_states[region_index] = active_state_switching::after_guard(current_state,next_state); // the guard condition has already been checked execute_exit<current_state_type> (::boost::fusion::at_key<current_state_type>(fsm.m_substate_list),evt,fsm); fsm.m_states[region_index] = active_state_switching::after_exit(current_state,next_state); fsm.m_states[region_index] = active_state_switching::after_action(current_state,next_state); // and finally the entry method of the new current state convert_event_and_execute_entry<next_state_type,T2> (::boost::fusion::at_key<next_state_type>(fsm.m_substate_list),evt,fsm); fsm.m_states[region_index] = active_state_switching::after_entry(current_state,next_state); return HANDLED_TRUE; } }; // row having only an action method template< typename ROW > struct a_row_ { //typedef typename ROW::Source T1; typedef typename make_entry<typename ROW::Source,library_sm>::type T1; typedef typename make_exit<typename ROW::Target,library_sm>::type T2; typedef typename ROW::Evt transition_event; // if the source is an exit pseudo state, then // current_state_type becomes the result of get_owner // meaning the containing SM from which the exit occurs typedef typename ::boost::mpl::eval_if< typename has_pseudo_exit<T1>::type, get_owner<T1,library_sm>, ::boost::mpl::identity<typename ROW::Source> >::type current_state_type; // if Target is a sequence, then we have a fork and expect a sequence of explicit_entry // else if Target is an explicit_entry, next_state_type becomes the result of get_owner // meaning the containing SM if the row is "outside" the containing SM or else the explicit_entry state itself typedef typename ::boost::mpl::eval_if< typename ::boost::mpl::is_sequence<T2>::type, get_fork_owner<T2,library_sm>, ::boost::mpl::eval_if< typename has_no_automatic_create<T2>::type, get_owner<T2,library_sm>, ::boost::mpl::identity<T2> > >::type next_state_type; // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int region_index, int state, transition_event const& evt) { BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value)); BOOST_STATIC_CONSTANT(int, next_state = (get_state_id<stt,next_state_type>::type::value)); BOOST_ASSERT(state == (current_state)); // if T1 is an exit pseudo state, then take the transition only if the pseudo exit state is active if (has_pseudo_exit<T1>::type::value && !is_exit_state_active<T1,get_owner<T1,library_sm> >(fsm)) { return HANDLED_FALSE; } fsm.m_states[region_index] = active_state_switching::after_guard(current_state,next_state); // no need to check the guard condition // first call the exit method of the current state execute_exit<current_state_type> (::boost::fusion::at_key<current_state_type>(fsm.m_substate_list),evt,fsm); fsm.m_states[region_index] = active_state_switching::after_exit(current_state,next_state); // then call the action method HandledEnum res = ROW::action_call(fsm,evt, ::boost::fusion::at_key<current_state_type>(fsm.m_substate_list), ::boost::fusion::at_key<next_state_type>(fsm.m_substate_list), fsm.m_substate_list); fsm.m_states[region_index] = active_state_switching::after_action(current_state,next_state); // and finally the entry method of the new current state convert_event_and_execute_entry<next_state_type,T2> (::boost::fusion::at_key<next_state_type>(fsm.m_substate_list),evt,fsm); fsm.m_states[region_index] = active_state_switching::after_entry(current_state,next_state); return res; } }; // row having no guard condition or action, simply transitions template< typename ROW > struct _row_ { //typedef typename ROW::Source T1; typedef typename make_entry<typename ROW::Source,library_sm>::type T1; typedef typename make_exit<typename ROW::Target,library_sm>::type T2; typedef typename ROW::Evt transition_event; // if the source is an exit pseudo state, then // current_state_type becomes the result of get_owner // meaning the containing SM from which the exit occurs typedef typename ::boost::mpl::eval_if< typename has_pseudo_exit<T1>::type, get_owner<T1,library_sm>, ::boost::mpl::identity<typename ROW::Source> >::type current_state_type; // if Target is a sequence, then we have a fork and expect a sequence of explicit_entry // else if Target is an explicit_entry, next_state_type becomes the result of get_owner // meaning the containing SM if the row is "outside" the containing SM or else the explicit_entry state itself typedef typename ::boost::mpl::eval_if< typename ::boost::mpl::is_sequence<T2>::type, get_fork_owner<T2,library_sm>, ::boost::mpl::eval_if< typename has_no_automatic_create<T2>::type, get_owner<T2,library_sm>, ::boost::mpl::identity<T2> > >::type next_state_type; // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int region_index, int state, transition_event const& evt) { BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value)); BOOST_STATIC_CONSTANT(int, next_state = (get_state_id<stt,next_state_type>::type::value)); BOOST_ASSERT(state == (current_state)); // if T1 is an exit pseudo state, then take the transition only if the pseudo exit state is active if (has_pseudo_exit<T1>::type::value && !is_exit_state_active<T1,get_owner<T1,library_sm> >(fsm)) { return HANDLED_FALSE; } fsm.m_states[region_index] = active_state_switching::after_guard(current_state,next_state); // first call the exit method of the current state execute_exit<current_state_type> (::boost::fusion::at_key<current_state_type>(fsm.m_substate_list),evt,fsm); fsm.m_states[region_index] = active_state_switching::after_exit(current_state,next_state); fsm.m_states[region_index] = active_state_switching::after_action(current_state,next_state); // and finally the entry method of the new current state convert_event_and_execute_entry<next_state_type,T2> (::boost::fusion::at_key<next_state_type>(fsm.m_substate_list),evt,fsm); fsm.m_states[region_index] = active_state_switching::after_entry(current_state,next_state); return HANDLED_TRUE; } }; // "i" rows are rows for internal transitions template< typename ROW > struct irow_ { typedef typename make_entry<typename ROW::Source,library_sm>::type T1; typedef typename make_exit<typename ROW::Target,library_sm>::type T2; typedef typename ROW::Evt transition_event; typedef typename ROW::Source current_state_type; typedef T2 next_state_type; // if a guard condition is here, call it to check that the event is accepted static bool check_guard(library_sm& fsm,transition_event const& evt) { if ( ROW::guard_call(fsm,evt, ::boost::fusion::at_key<current_state_type>(fsm.m_substate_list), ::boost::fusion::at_key<next_state_type>(fsm.m_substate_list), fsm.m_substate_list)) return true; return false; } // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int , int state, transition_event const& evt) { BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value)); BOOST_ASSERT(state == (current_state)); if (!check_guard(fsm,evt)) { // guard rejected the event, we stay in the current one return HANDLED_GUARD_REJECT; } // call the action method HandledEnum res = ROW::action_call(fsm,evt, ::boost::fusion::at_key<current_state_type>(fsm.m_substate_list), ::boost::fusion::at_key<next_state_type>(fsm.m_substate_list), fsm.m_substate_list); return res; } }; // row having only a guard condition template< typename ROW > struct g_irow_ { typedef typename make_entry<typename ROW::Source,library_sm>::type T1; typedef typename make_exit<typename ROW::Target,library_sm>::type T2; typedef typename ROW::Evt transition_event; typedef typename ROW::Source current_state_type; typedef T2 next_state_type; // if a guard condition is defined, call it to check that the event is accepted static bool check_guard(library_sm& fsm,transition_event const& evt) { if ( ROW::guard_call(fsm,evt, ::boost::fusion::at_key<current_state_type>(fsm.m_substate_list), ::boost::fusion::at_key<next_state_type>(fsm.m_substate_list), fsm.m_substate_list) ) return true; return false; } // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int , int state, transition_event const& evt) { BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value)); BOOST_ASSERT(state == (current_state)); if (!check_guard(fsm,evt)) { // guard rejected the event, we stay in the current one return HANDLED_GUARD_REJECT; } return HANDLED_TRUE; } }; // row having only an action method template< typename ROW > struct a_irow_ { typedef typename make_entry<typename ROW::Source,library_sm>::type T1; typedef typename make_exit<typename ROW::Target,library_sm>::type T2; typedef typename ROW::Evt transition_event; typedef typename ROW::Source current_state_type; typedef T2 next_state_type; // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int , int state, transition_event const& evt) { BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value)); BOOST_ASSERT(state == (current_state)); // call the action method HandledEnum res = ROW::action_call(fsm,evt, ::boost::fusion::at_key<current_state_type>(fsm.m_substate_list), ::boost::fusion::at_key<next_state_type>(fsm.m_substate_list), fsm.m_substate_list); return res; } }; // row simply ignoring the event template< typename ROW > struct _irow_ { typedef typename make_entry<typename ROW::Source,library_sm>::type T1; typedef typename make_exit<typename ROW::Target,library_sm>::type T2; typedef typename ROW::Evt transition_event; typedef typename ROW::Source current_state_type; typedef T2 next_state_type; // Take the transition action and return the next state. static HandledEnum execute(library_sm& , int , int state, transition_event const& ) { BOOST_STATIC_CONSTANT(int, current_state = (get_state_id<stt,current_state_type>::type::value)); BOOST_ASSERT(state == (current_state)); return HANDLED_TRUE; } }; // transitions internal to this state machine (no substate involved) template< typename ROW, typename StateType > struct internal_ { typedef StateType current_state_type; typedef StateType next_state_type; typedef typename ROW::Evt transition_event; // if a guard condition is here, call it to check that the event is accepted static bool check_guard(library_sm& fsm,transition_event const& evt) { if ( ROW::guard_call(fsm,evt, ::boost::fusion::at_key<StateType>(fsm.m_substate_list), ::boost::fusion::at_key<StateType>(fsm.m_substate_list), fsm.m_substate_list) ) return true; return false; } // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int , int , transition_event const& evt) { if (!check_guard(fsm,evt)) { // guard rejected the event, we stay in the current one return HANDLED_GUARD_REJECT; } // then call the action method HandledEnum res = ROW::action_call(fsm,evt, ::boost::fusion::at_key<StateType>(fsm.m_substate_list), ::boost::fusion::at_key<StateType>(fsm.m_substate_list), fsm.m_substate_list); return res; } }; template< typename ROW > struct internal_ <ROW,library_sm> { typedef library_sm current_state_type; typedef library_sm next_state_type; typedef typename ROW::Evt transition_event; // if a guard condition is here, call it to check that the event is accepted static bool check_guard(library_sm& fsm,transition_event const& evt) { if ( ROW::guard_call(fsm,evt, fsm, fsm, fsm.m_substate_list) ) return true; return false; } // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int , int , transition_event const& evt) { if (!check_guard(fsm,evt)) { // guard rejected the event, we stay in the current one return HANDLED_GUARD_REJECT; } // then call the action method HandledEnum res = ROW::action_call(fsm,evt, fsm, fsm, fsm.m_substate_list); return res; } }; template< typename ROW, typename StateType > struct a_internal_ { typedef StateType current_state_type; typedef StateType next_state_type; typedef typename ROW::Evt transition_event; // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int, int, transition_event const& evt) { // then call the action method HandledEnum res = ROW::action_call(fsm,evt, ::boost::fusion::at_key<StateType>(fsm.m_substate_list), ::boost::fusion::at_key<StateType>(fsm.m_substate_list), fsm.m_substate_list); return res; } }; template< typename ROW > struct a_internal_ <ROW,library_sm> { typedef library_sm current_state_type; typedef library_sm next_state_type; typedef typename ROW::Evt transition_event; // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int, int, transition_event const& evt) { // then call the action method HandledEnum res = ROW::action_call(fsm,evt, fsm, fsm, fsm.m_substate_list); return res; } }; template< typename ROW, typename StateType > struct g_internal_ { typedef StateType current_state_type; typedef StateType next_state_type; typedef typename ROW::Evt transition_event; // if a guard condition is here, call it to check that the event is accepted static bool check_guard(library_sm& fsm,transition_event const& evt) { if ( ROW::guard_call(fsm,evt, ::boost::fusion::at_key<StateType>(fsm.m_substate_list), ::boost::fusion::at_key<StateType>(fsm.m_substate_list), fsm.m_substate_list) ) return true; return false; } // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int, int, transition_event const& evt) { if (!check_guard(fsm,evt)) { // guard rejected the event, we stay in the current one return HANDLED_GUARD_REJECT; } return HANDLED_TRUE; } }; template< typename ROW > struct g_internal_ <ROW,library_sm> { typedef library_sm current_state_type; typedef library_sm next_state_type; typedef typename ROW::Evt transition_event; // if a guard condition is here, call it to check that the event is accepted static bool check_guard(library_sm& fsm,transition_event const& evt) { if ( ROW::guard_call(fsm,evt, fsm, fsm, fsm.m_substate_list) ) return true; return false; } // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int, int, transition_event const& evt) { if (!check_guard(fsm,evt)) { // guard rejected the event, we stay in the current one return HANDLED_GUARD_REJECT; } return HANDLED_TRUE; } }; template< typename ROW, typename StateType > struct _internal_ { typedef StateType current_state_type; typedef StateType next_state_type; typedef typename ROW::Evt transition_event; static HandledEnum execute(library_sm& , int , int , transition_event const& ) { return HANDLED_TRUE; } }; template< typename ROW > struct _internal_ <ROW,library_sm> { typedef library_sm current_state_type; typedef library_sm next_state_type; typedef typename ROW::Evt transition_event; static HandledEnum execute(library_sm& , int , int , transition_event const& ) { return HANDLED_TRUE; } }; // Template used to form forwarding rows in the transition table for every row of a composite SM template< typename T1 , class Evt > struct frow { typedef T1 current_state_type; typedef T1 next_state_type; typedef Evt transition_event; // tag to find out if a row is a forwarding row typedef int is_frow; // Take the transition action and return the next state. static HandledEnum execute(library_sm& fsm, int region_index, int , transition_event const& evt) { // false as second parameter because this event is forwarded from outer fsm execute_return res = (::boost::fusion::at_key<current_state_type>(fsm.m_substate_list)).process_event_internal(evt); fsm.m_states[region_index]=get_state_id<stt,T1>::type::value; return res; } // helper metafunctions used by dispatch table and give the frow a new event // (used to avoid double entries in a table because of base events) template <class NewEvent> struct replace_event { typedef frow<T1,NewEvent> type; }; }; template <class Tag, class Transition,class StateType> struct create_backend_stt { }; template <class Transition,class StateType> struct create_backend_stt<g_row_tag,Transition,StateType> { typedef g_row_<Transition> type; }; template <class Transition,class StateType> struct create_backend_stt<a_row_tag,Transition,StateType> { typedef a_row_<Transition> type; }; template <class Transition,class StateType> struct create_backend_stt<_row_tag,Transition,StateType> { typedef _row_<Transition> type; }; template <class Transition,class StateType> struct create_backend_stt<row_tag,Transition,StateType> { typedef row_<Transition> type; }; // internal transitions template <class Transition,class StateType> struct create_backend_stt<g_irow_tag,Transition,StateType> { typedef g_irow_<Transition> type; }; template <class Transition,class StateType> struct create_backend_stt<a_irow_tag,Transition,StateType> { typedef a_irow_<Transition> type; }; template <class Transition,class StateType> struct create_backend_stt<irow_tag,Transition,StateType> { typedef irow_<Transition> type; }; template <class Transition,class StateType> struct create_backend_stt<_irow_tag,Transition,StateType> { typedef _irow_<Transition> type; }; template <class Transition,class StateType> struct create_backend_stt<sm_a_i_row_tag,Transition,StateType> { typedef a_internal_<Transition,StateType> type; }; template <class Transition,class StateType> struct create_backend_stt<sm_g_i_row_tag,Transition,StateType> { typedef g_internal_<Transition,StateType> type; }; template <class Transition,class StateType> struct create_backend_stt<sm_i_row_tag,Transition,StateType> { typedef internal_<Transition,StateType> type; }; template <class Transition,class StateType> struct create_backend_stt<sm__i_row_tag,Transition,StateType> { typedef _internal_<Transition,StateType> type; }; template <class Transition,class StateType=void> struct make_row_tag { typedef typename create_backend_stt<typename Transition::row_type_tag,Transition,StateType>::type type; }; // add to the stt the initial states which could be missing (if not being involved in a transition) template <class BaseType, class stt_simulated = typename BaseType::transition_table> struct create_real_stt { //typedef typename BaseType::transition_table stt_simulated; typedef typename ::boost::mpl::fold< stt_simulated,mpl::vector0<>, ::boost::mpl::push_back< ::boost::mpl::placeholders::_1, make_row_tag< ::boost::mpl::placeholders::_2 , BaseType > > >::type type; }; template <class Table,class Intermediate,class StateType> struct add_forwarding_row_helper { typedef typename generate_event_set<Table>::type all_events; typedef typename ::boost::mpl::fold< all_events, Intermediate, ::boost::mpl::push_back< ::boost::mpl::placeholders::_1, frow<StateType, ::boost::mpl::placeholders::_2> > >::type type; }; // gets the transition table from a composite and make from it a forwarding row template <class StateType,class IsComposite> struct get_internal_transition_table { // first get the table of a composite typedef typename recursive_get_transition_table<StateType>::type original_table; // we now look for the events the composite has in its internal transitions // the internal ones are searched recursively in sub-sub... states // we go recursively because our states can also have internal tables or substates etc. typedef typename recursive_get_internal_transition_table<StateType, ::boost::mpl::true_>::type recursive_istt; typedef typename ::boost::mpl::fold< recursive_istt,::boost::mpl::vector0<>, ::boost::mpl::push_back< ::boost::mpl::placeholders::_1, make_row_tag< ::boost::mpl::placeholders::_2 , StateType> > >::type recursive_istt_with_tag; typedef typename ::boost::mpl::insert_range< original_table, typename ::boost::mpl::end<original_table>::type, recursive_istt_with_tag>::type table_with_all_events; // and add for every event a forwarding row typedef typename ::boost::mpl::eval_if< typename CompilePolicy::add_forwarding_rows, add_forwarding_row_helper<table_with_all_events,::boost::mpl::vector0<>,StateType>, ::boost::mpl::identity< ::boost::mpl::vector0<> > >::type type; }; template <class StateType> struct get_internal_transition_table<StateType, ::boost::mpl::false_ > { typedef typename create_real_stt<StateType, typename StateType::internal_transition_table >::type type; }; // typedefs used internally typedef typename create_real_stt<Derived>::type real_transition_table; typedef typename create_stt<library_sm>::type stt; typedef typename get_initial_states<typename Derived::initial_state>::type initial_states; typedef typename generate_state_set<stt>::type state_list; typedef typename HistoryPolicy::template apply<nr_regions::value>::type concrete_history; typedef typename ::boost::fusion::result_of::as_set<state_list>::type substate_list; typedef typename ::boost::msm::back::generate_event_set< typename create_real_stt<library_sm, typename library_sm::internal_transition_table >::type >::type processable_events_internal_table; // extends the transition table with rows from composite states template <class Composite> struct extend_table { // add the init states //typedef typename create_stt<Composite>::type stt; typedef typename Composite::stt Stt; // add the internal events defined in the internal_transition_table // Note: these are added first because they must have a lesser prio // than the deeper transitions in the sub regions // table made of a stt + internal transitions of composite typedef typename ::boost::mpl::fold< typename Composite::internal_transition_table,::boost::mpl::vector0<>, ::boost::mpl::push_back< ::boost::mpl::placeholders::_1, make_row_tag< ::boost::mpl::placeholders::_2 , Composite> > >::type internal_stt; typedef typename ::boost::mpl::insert_range< Stt, typename ::boost::mpl::end<Stt>::type, internal_stt //typename get_internal_transition_table<Composite, ::boost::mpl::true_ >::type >::type stt_plus_internal; // for every state, add its transition table (if any) // transformed as frow typedef typename ::boost::mpl::fold<state_list,stt_plus_internal, ::boost::mpl::insert_range< ::boost::mpl::placeholders::_1, ::boost::mpl::end< ::boost::mpl::placeholders::_1>, get_internal_transition_table< ::boost::mpl::placeholders::_2, is_composite_state< ::boost::mpl::placeholders::_2> > > >::type type; }; // extend the table with tables from composite states typedef typename extend_table<library_sm>::type complete_table; // build a sequence of regions typedef typename get_regions_as_sequence<typename Derived::initial_state>::type seq_initial_states; // Member functions // start the state machine (calls entry of the initial state) void start() { // reinitialize our list of currently active states with the ones defined in Derived::initial_state ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > (init_states(m_states)); // call on_entry on this SM (static_cast<Derived*>(this))->on_entry(fsm_initial_event(),*this); ::boost::mpl::for_each<initial_states, boost::msm::wrap<mpl::placeholders::_1> > (call_init<fsm_initial_event>(fsm_initial_event(),this)); // give a chance to handle an anonymous (eventless) transition handle_eventless_transitions_helper<library_sm> eventless_helper(this,true); eventless_helper.process_completion_event(); } // start the state machine (calls entry of the initial state passing incomingEvent to on_entry's) template <class Event> void start(Event const& incomingEvent) { // reinitialize our list of currently active states with the ones defined in Derived::initial_state ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > (init_states(m_states)); // call on_entry on this SM (static_cast<Derived*>(this))->on_entry(incomingEvent,*this); ::boost::mpl::for_each<initial_states, boost::msm::wrap<mpl::placeholders::_1> > (call_init<Event>(incomingEvent,this)); // give a chance to handle an anonymous (eventless) transition handle_eventless_transitions_helper<library_sm> eventless_helper(this,true); eventless_helper.process_completion_event(); } // stop the state machine (calls exit of the current state) void stop() { do_exit(fsm_final_event(),*this); } // stop the state machine (calls exit of the current state passing finalEvent to on_exit's) template <class Event> void stop(Event const& finalEvent) { do_exit(finalEvent,*this); } // Main function used by clients of the derived FSM to make transitions. template<class Event> execute_return process_event(Event const& evt) { return process_event_internal(evt, EVENT_SOURCE_DIRECT); } template <class EventType> void enqueue_event_helper(EventType const& evt, ::boost::mpl::false_ const &) { execute_return (library_sm::*pf) (EventType const&, EventSource) = &library_sm::process_event_internal; m_events_queue.m_events_queue.push_back( ::boost::bind( pf, this, evt, static_cast<EventSource>(EVENT_SOURCE_MSG_QUEUE))); } template <class EventType> void enqueue_event_helper(EventType const& , ::boost::mpl::true_ const &) { // no queue } void execute_queued_events_helper(::boost::mpl::false_ const &) { while(!m_events_queue.m_events_queue.empty()) { transition_fct to_call = m_events_queue.m_events_queue.front(); m_events_queue.m_events_queue.pop_front(); to_call(); } } void execute_queued_events_helper(::boost::mpl::true_ const &) { // no queue required } void execute_single_queued_event_helper(::boost::mpl::false_ const &) { transition_fct to_call = m_events_queue.m_events_queue.front(); m_events_queue.m_events_queue.pop_front(); to_call(); } void execute_single_queued_event_helper(::boost::mpl::true_ const &) { // no queue required } // enqueues an event in the message queue // call execute_queued_events to process all queued events. // Be careful if you do this during event processing, the event will be processed immediately // and not kept in the queue template <class EventType> void enqueue_event(EventType const& evt) { enqueue_event_helper<EventType>(evt, typename is_no_message_queue<library_sm>::type()); } // empty the queue and process events void execute_queued_events() { execute_queued_events_helper(typename is_no_message_queue<library_sm>::type()); } void execute_single_queued_event() { execute_single_queued_event_helper(typename is_no_message_queue<library_sm>::type()); } typename events_queue_t::size_type get_message_queue_size() const { return m_events_queue.m_events_queue.size(); } events_queue_t& get_message_queue() { return m_events_queue.m_events_queue; } const events_queue_t& get_message_queue() const { return m_events_queue.m_events_queue; } void clear_deferred_queue() { m_deferred_events_queue.clear(); } deferred_events_queue_t& get_deferred_queue() { return m_deferred_events_queue.m_deferred_events_queue; } const deferred_events_queue_t& get_deferred_queue() const { return m_deferred_events_queue.m_deferred_events_queue; } // Getter that returns the current state of the FSM const int* current_state() const { return this->m_states; } template <class Archive> struct serialize_state { serialize_state(Archive& ar):ar_(ar){} template<typename T> typename ::boost::enable_if< typename ::boost::mpl::or_< typename has_do_serialize<T>::type, typename is_composite_state<T>::type >::type ,void >::type operator()(T& t) const { ar_ & t; } template<typename T> typename ::boost::disable_if< typename ::boost::mpl::or_< typename has_do_serialize<T>::type, typename is_composite_state<T>::type >::type ,void >::type operator()(T&) const { // no state to serialize } Archive& ar_; }; template<class Archive> void serialize(Archive & ar, const unsigned int) { // invoke serialization of the base class (serialize_state<Archive>(ar))(boost::serialization::base_object<Derived>(*this)); // now our attributes ar & m_states; // queues cannot be serialized => skip ar & m_history; ar & m_event_processing; ar & m_is_included; // visitors cannot be serialized => skip ::boost::fusion::for_each(m_substate_list, serialize_state<Archive>(ar)); } // linearly search for the state with the given id struct get_state_id_helper { get_state_id_helper(int id,const BaseState** res,const library_sm* self_): result_state(res),searched_id(id),self(self_) {} template <class StateType> void operator()(boost::msm::wrap<StateType> const&) { // look for the state id until found BOOST_STATIC_CONSTANT(int, id = (get_state_id<stt,StateType>::value)); if (!*result_state && (id == searched_id)) { *result_state = &::boost::fusion::at_key<StateType>(self->m_substate_list); } } const BaseState** result_state; int searched_id; const library_sm* self; }; // return the state whose id is passed or 0 if not found // caution if you need this, you probably need polymorphic states // complexity: O(number of states) BaseState* get_state_by_id(int id) { const BaseState* result_state=0; ::boost::mpl::for_each<state_list, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > (get_state_id_helper(id,&result_state,this)); return const_cast<BaseState*>(result_state); } const BaseState* get_state_by_id(int id) const { const BaseState* result_state=0; ::boost::mpl::for_each<state_list, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > (get_state_id_helper(id,&result_state,this)); return result_state; } // true if the sm is used in another sm bool is_contained() const { return m_is_included; } // get the history policy class concrete_history& get_history() { return m_history; } concrete_history const& get_history() const { return m_history; } // get a state (const version) // as a pointer template <class State> typename ::boost::enable_if<typename ::boost::is_pointer<State>::type,State >::type get_state(::boost::msm::back::dummy<0> = 0) const { return const_cast<State > (& (::boost::fusion::at_key< typename ::boost::remove_const<typename ::boost::remove_pointer<State>::type>::type>(m_substate_list))); } // as a reference template <class State> typename ::boost::enable_if<typename ::boost::is_reference<State>::type,State >::type get_state(::boost::msm::back::dummy<1> = 0) const { return const_cast<State > ( ::boost::fusion::at_key< typename ::boost::remove_const<typename ::boost::remove_reference<State>::type>::type>(m_substate_list) ); } // get a state (non const version) // as a pointer template <class State> typename ::boost::enable_if<typename ::boost::is_pointer<State>::type,State >::type get_state(::boost::msm::back::dummy<0> = 0) { return &(static_cast<typename boost::add_reference<typename ::boost::remove_pointer<State>::type>::type > (::boost::fusion::at_key<typename ::boost::remove_pointer<State>::type>(m_substate_list))); } // as a reference template <class State> typename ::boost::enable_if<typename ::boost::is_reference<State>::type,State >::type get_state(::boost::msm::back::dummy<1> = 0) { return ::boost::fusion::at_key<typename ::boost::remove_reference<State>::type>(m_substate_list); } // checks if a flag is active using the BinaryOp as folding function template <class Flag,class BinaryOp> bool is_flag_active() const { flag_handler* flags_entries = get_entries_for_flag<Flag>(); bool res = (*flags_entries[ m_states[0] ])(*this); for (int i = 1; i < nr_regions::value ; ++i) { res = typename BinaryOp::type() (res,(*flags_entries[ m_states[i] ])(*this)); } return res; } // checks if a flag is active using no binary op if 1 region, or OR if > 1 regions template <class Flag> bool is_flag_active() const { return FlagHelper<Flag,(nr_regions::value>1)>::helper(*this,get_entries_for_flag<Flag>()); } // visit the currently active states (if these are defined as visitable // by implementing accept) void visit_current_states() { for (int i=0; i<nr_regions::value;++i) { m_visitors.execute(m_states[i]); } } #define MSM_VISIT_STATE_SUB(z, n, unused) ARG ## n vis ## n #define MSM_VISIT_STATE_EXECUTE(z, n, unused) \ template <BOOST_PP_ENUM_PARAMS(n, class ARG)> \ void visit_current_states(BOOST_PP_ENUM(n, MSM_VISIT_STATE_SUB, ~ ) ) \ { \ for (int i=0; i<nr_regions::value;++i) \ { \ m_visitors.execute(m_states[i],BOOST_PP_ENUM_PARAMS(n,vis)); \ } \ } BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_ADD(BOOST_MSM_VISITOR_ARG_SIZE,1), MSM_VISIT_STATE_EXECUTE, ~) #undef MSM_VISIT_STATE_EXECUTE #undef MSM_VISIT_STATE_SUB // puts the given event into the deferred queue template <class Event> void defer_event(Event const& e) { // to call this function, you need either a state with a deferred_events typedef // or that the fsm provides the activate_deferred_events typedef BOOST_MPL_ASSERT(( has_fsm_deferred_events<library_sm> )); execute_return (library_sm::*pf) (Event const&, EventSource) = &library_sm::process_event_internal; // Deferred events are added with a correlation sequence that helps to // identify when an event was added - This is typically to distinguish // between events deferred in this processing versus previous. m_deferred_events_queue.m_deferred_events_queue.push_back( std::make_pair( ::boost::bind( pf, this, e, static_cast<EventSource>(EVENT_SOURCE_DIRECT|EVENT_SOURCE_DEFERRED)), static_cast<char>(m_deferred_events_queue.m_cur_seq+1))); } protected: // interface for the derived class // helper used to fill the initial states struct init_states { init_states(int* const init):m_initial_states(init),m_index(-1){} // History initializer function object, used with mpl::for_each template <class State> void operator()(::boost::msm::wrap<State> const&) { m_initial_states[++m_index]=get_state_id<stt,State>::type::value; } int* const m_initial_states; int m_index; }; public: struct update_state { update_state(substate_list& to_overwrite_):to_overwrite(&to_overwrite_){} template<typename StateType> void operator()(StateType const& astate) const { ::boost::fusion::at_key<StateType>(*to_overwrite)=astate; } substate_list* to_overwrite; }; template <class Expr> void set_states(Expr const& expr) { ::boost::fusion::for_each( ::boost::fusion::as_vector(FoldToList()(expr, boost::fusion::nil_())),update_state(this->m_substate_list)); } // Construct with the default initial states state_machine<A0,A1,A2,A3,A4 >() :Derived() ,m_events_queue() ,m_deferred_events_queue() ,m_history() ,m_event_processing(false) ,m_is_included(false) ,m_visitors() ,m_substate_list() { // initialize our list of states with the ones defined in Derived::initial_state ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > (init_states(m_states)); m_history.set_initial_states(m_states); // create states fill_states(this); } template <class Expr> state_machine<A0,A1,A2,A3,A4 > (Expr const& expr,typename ::boost::enable_if<typename ::boost::proto::is_expr<Expr>::type >::type* =0) :Derived() ,m_events_queue() ,m_deferred_events_queue() ,m_history() ,m_event_processing(false) ,m_is_included(false) ,m_visitors() ,m_substate_list() { BOOST_MPL_ASSERT_MSG( ( ::boost::proto::matches<Expr, FoldToList>::value), THE_STATES_EXPRESSION_PASSED_DOES_NOT_MATCH_GRAMMAR, (FoldToList)); // initialize our list of states with the ones defined in Derived::initial_state ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > (init_states(m_states)); m_history.set_initial_states(m_states); // create states set_states(expr); fill_states(this); } // Construct with the default initial states and some default argument(s) #if defined (BOOST_NO_CXX11_RVALUE_REFERENCES) \ || defined (BOOST_NO_CXX11_VARIADIC_TEMPLATES) \ || defined (BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) #define MSM_CONSTRUCTOR_HELPER_EXECUTE_SUB(z, n, unused) ARG ## n t ## n #define MSM_CONSTRUCTOR_HELPER_EXECUTE(z, n, unused) \ template <BOOST_PP_ENUM_PARAMS(n, class ARG)> \ state_machine<A0,A1,A2,A3,A4 \ >(BOOST_PP_ENUM(n, MSM_CONSTRUCTOR_HELPER_EXECUTE_SUB, ~ ), \ typename ::boost::disable_if<typename ::boost::proto::is_expr<ARG0>::type >::type* =0 ) \ :Derived(BOOST_PP_ENUM_PARAMS(n,t)) \ ,m_events_queue() \ ,m_deferred_events_queue() \ ,m_history() \ ,m_event_processing(false) \ ,m_is_included(false) \ ,m_visitors() \ ,m_substate_list() \ { \ ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > \ (init_states(m_states)); \ m_history.set_initial_states(m_states); \ fill_states(this); \ } \ template <class Expr,BOOST_PP_ENUM_PARAMS(n, class ARG)> \ state_machine<A0,A1,A2,A3,A4 \ >(Expr const& expr,BOOST_PP_ENUM(n, MSM_CONSTRUCTOR_HELPER_EXECUTE_SUB, ~ ), \ typename ::boost::enable_if<typename ::boost::proto::is_expr<Expr>::type >::type* =0 ) \ :Derived(BOOST_PP_ENUM_PARAMS(n,t)) \ ,m_events_queue() \ ,m_deferred_events_queue() \ ,m_history() \ ,m_event_processing(false) \ ,m_is_included(false) \ ,m_visitors() \ ,m_substate_list() \ { \ BOOST_MPL_ASSERT_MSG( \ ( ::boost::proto::matches<Expr, FoldToList>::value), \ THE_STATES_EXPRESSION_PASSED_DOES_NOT_MATCH_GRAMMAR, \ (FoldToList)); \ ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > \ (init_states(m_states)); \ m_history.set_initial_states(m_states); \ set_states(expr); \ fill_states(this); \ } BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_ADD(BOOST_MSM_CONSTRUCTOR_ARG_SIZE,1), MSM_CONSTRUCTOR_HELPER_EXECUTE, ~) #undef MSM_CONSTRUCTOR_HELPER_EXECUTE #undef MSM_CONSTRUCTOR_HELPER_EXECUTE_SUB #else template <class ARG0,class... ARG,class=typename ::boost::disable_if<typename ::boost::proto::is_expr<ARG0>::type >::type> state_machine<A0,A1,A2,A3,A4 >(ARG0&& t0,ARG&&... t) :Derived(std::forward<ARG0>(t0), std::forward<ARG>(t)...) ,m_events_queue() ,m_deferred_events_queue() ,m_history() ,m_event_processing(false) ,m_is_included(false) ,m_visitors() ,m_substate_list() { ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > (init_states(m_states)); m_history.set_initial_states(m_states); fill_states(this); } template <class Expr,class... ARG,class=typename ::boost::enable_if<typename ::boost::proto::is_expr<Expr>::type >::type> state_machine<A0,A1,A2,A3,A4 >(Expr const& expr,ARG&&... t) :Derived(std::forward<ARG>(t)...) ,m_events_queue() ,m_deferred_events_queue() ,m_history() ,m_event_processing(false) ,m_is_included(false) ,m_visitors() ,m_substate_list() { BOOST_MPL_ASSERT_MSG( ( ::boost::proto::matches<Expr, FoldToList>::value), THE_STATES_EXPRESSION_PASSED_DOES_NOT_MATCH_GRAMMAR, (FoldToList)); ::boost::mpl::for_each< seq_initial_states, ::boost::msm::wrap<mpl::placeholders::_1> > (init_states(m_states)); m_history.set_initial_states(m_states); set_states(expr); fill_states(this); } #endif // assignment operator using the copy policy to decide if non_copyable, shallow or deep copying is necessary library_sm& operator= (library_sm const& rhs) { if (this != &rhs) { Derived::operator=(rhs); do_copy(rhs); } return *this; } state_machine<A0,A1,A2,A3,A4> (library_sm const& rhs) : Derived(rhs) { if (this != &rhs) { // initialize our list of states with the ones defined in Derived::initial_state fill_states(this); do_copy(rhs); } } // the following 2 functions handle the terminate/interrupt states handling // if one of these states is found, the first one is used template <class Event> bool is_event_handling_blocked_helper( ::boost::mpl::true_ const &) { // if the state machine is terminated, do not handle any event if (is_flag_active< ::boost::msm::TerminateFlag>()) return true; // if the state machine is interrupted, do not handle any event // unless the event is the end interrupt event if ( is_flag_active< ::boost::msm::InterruptedFlag>() && !is_flag_active< ::boost::msm::EndInterruptFlag<Event> >()) return true; return false; } // otherwise simple handling, no flag => continue template <class Event> bool is_event_handling_blocked_helper( ::boost::mpl::false_ const &) { // no terminate/interrupt states detected return false; } void do_handle_prio_msg_queue_deferred_queue(EventSource source, HandledEnum handled, ::boost::mpl::true_ const &) { // non-default. Handle msg queue with higher prio than deferred queue if (!(EVENT_SOURCE_MSG_QUEUE & source)) { do_post_msg_queue_helper( ::boost::mpl::bool_< is_no_message_queue<library_sm>::type::value>()); if (!(EVENT_SOURCE_DEFERRED & source)) { handle_defer_helper<library_sm> defer_helper(m_deferred_events_queue); defer_helper.do_handle_deferred(HANDLED_TRUE & handled); } } } void do_handle_prio_msg_queue_deferred_queue(EventSource source, HandledEnum handled, ::boost::mpl::false_ const &) { // default. Handle deferred queue with higher prio than msg queue if (!(EVENT_SOURCE_DEFERRED & source)) { handle_defer_helper<library_sm> defer_helper(m_deferred_events_queue); defer_helper.do_handle_deferred(HANDLED_TRUE & handled); // Handle any new events generated into the queue, but only if // we're not already processing from the message queue. if (!(EVENT_SOURCE_MSG_QUEUE & source)) { do_post_msg_queue_helper( ::boost::mpl::bool_< is_no_message_queue<library_sm>::type::value>()); } } } // the following functions handle pre/post-process handling of a message queue template <class StateType,class EventType> bool do_pre_msg_queue_helper(EventType const&, ::boost::mpl::true_ const &) { // no message queue needed return true; } template <class StateType,class EventType> bool do_pre_msg_queue_helper(EventType const& evt, ::boost::mpl::false_ const &) { execute_return (library_sm::*pf) (EventType const&, EventSource) = &library_sm::process_event_internal; // if we are already processing an event if (m_event_processing) { // event has to be put into the queue m_events_queue.m_events_queue.push_back( ::boost::bind( pf, this, evt, static_cast<EventSource>(EVENT_SOURCE_DIRECT | EVENT_SOURCE_MSG_QUEUE))); return false; } // event can be handled, processing m_event_processing = true; return true; } void do_post_msg_queue_helper( ::boost::mpl::true_ const &) { // no message queue needed } void do_post_msg_queue_helper( ::boost::mpl::false_ const &) { process_message_queue(this); } void do_allow_event_processing_after_transition( ::boost::mpl::true_ const &) { // no message queue needed } void do_allow_event_processing_after_transition( ::boost::mpl::false_ const &) { m_event_processing = false; } // the following 2 functions handle the processing either with a try/catch protection or without template <class StateType,class EventType> HandledEnum do_process_helper(EventType const& evt, ::boost::mpl::true_ const &, bool is_direct_call) { return this->do_process_event(evt,is_direct_call); } template <class StateType,class EventType> HandledEnum do_process_helper(EventType const& evt, ::boost::mpl::false_ const &, bool is_direct_call) { // when compiling without exception support there is no formal parameter "e" in the catch handler. // Declaring a local variable here does not hurt and will be "used" to make the code in the handler // compilable although the code will never be executed. std::exception e; BOOST_TRY { return this->do_process_event(evt,is_direct_call); } BOOST_CATCH (std::exception& e) { // give a chance to the concrete state machine to handle this->exception_caught(evt,*this,e); } BOOST_CATCH_END return HANDLED_TRUE; } // handling of deferred events // if none is found in the SM, take the following empty main version template <class StateType, class Enable = int> struct handle_defer_helper { handle_defer_helper(deferred_msg_queue_helper<library_sm>& ){} void do_handle_deferred(bool) { } }; // otherwise the standard version handling the deferred events template <class StateType> struct handle_defer_helper <StateType, typename enable_if< typename ::boost::msm::back::has_fsm_deferred_events<StateType>::type,int >::type> { handle_defer_helper(deferred_msg_queue_helper<library_sm>& a_queue): m_events_queue(a_queue) {} void do_handle_deferred(bool new_seq=false) { // A new sequence is typically started upon initial entry to the // state, or upon a new transition. When this occurs we want to // process all previously deferred events by incrementing the // correlation sequence. if (new_seq) { ++m_events_queue.m_cur_seq; } char& cur_seq = m_events_queue.m_cur_seq; // Iteratively process all of the events within the deferred // queue upto (but not including) newly deferred events. while (!m_events_queue.m_deferred_events_queue.empty()) { typename deferred_events_queue_t::value_type& pair = m_events_queue.m_deferred_events_queue.front(); if (cur_seq != pair.second) { break; } deferred_fct next = pair.first; m_events_queue.m_deferred_events_queue.pop_front(); next(); } } private: deferred_msg_queue_helper<library_sm>& m_events_queue; }; // handling of eventless transitions // if none is found in the SM, nothing to do template <class StateType, class Enable = void> struct handle_eventless_transitions_helper { handle_eventless_transitions_helper(library_sm* , bool ){} void process_completion_event(EventSource = EVENT_SOURCE_DEFAULT){} }; // otherwise template <class StateType> struct handle_eventless_transitions_helper <StateType, typename enable_if< typename ::boost::msm::back::has_fsm_eventless_transition<StateType>::type >::type> { handle_eventless_transitions_helper(library_sm* self_, bool handled_):self(self_),handled(handled_){} void process_completion_event(EventSource source = EVENT_SOURCE_DEFAULT) { typedef typename ::boost::mpl::deref< typename ::boost::mpl::begin< typename find_completion_events<StateType>::type >::type >::type first_completion_event; if (handled) { self->process_event_internal( first_completion_event(), source | EVENT_SOURCE_DIRECT); } } private: library_sm* self; bool handled; }; // helper class called in case the event to process has been found in the fsm's internal stt and is therefore processable template<class Event> struct process_fsm_internal_table { typedef typename ::boost::mpl::has_key<processable_events_internal_table,Event>::type is_event_processable; // forward to the correct do_process static void process(Event const& evt,library_sm* self_,HandledEnum& result) { do_process(evt,self_,result,is_event_processable()); } private: // the event is processable, let's try! static void do_process(Event const& evt,library_sm* self_,HandledEnum& result, ::boost::mpl::true_) { if (result != HANDLED_TRUE) { typedef dispatch_table<library_sm,complete_table,Event,CompilePolicy> table; HandledEnum res_internal = table::instance.entries[0](*self_, 0, self_->m_states[0], evt); result = (HandledEnum)((int)result | (int)res_internal); } } // version doing nothing if the event is not in the internal stt and we can save ourselves the time trying to process static void do_process(Event const& ,library_sm* ,HandledEnum& , ::boost::mpl::false_) { // do nothing } }; template <class StateType,class Enable=void> struct region_processing_helper { public: region_processing_helper(library_sm* self_,HandledEnum& result_) :self(self_),result(result_){} template<class Event> void process(Event const& evt) { // use this table as if it came directly from the user typedef dispatch_table<library_sm,complete_table,Event,CompilePolicy> table; // +1 because index 0 is reserved for this fsm HandledEnum res = table::instance.entries[self->m_states[0]+1]( *self, 0, self->m_states[0], evt); result = (HandledEnum)((int)result | (int)res); // process the event in the internal table of this fsm if the event is processable (present in the table) process_fsm_internal_table<Event>::process(evt,self,result); } library_sm* self; HandledEnum& result; }; // version with visitors template <class StateType> struct region_processing_helper<StateType,typename ::boost::enable_if< ::boost::mpl::is_sequence<typename StateType::initial_state> >::type> { private: // process event in one region template <class region_id,int Dummy=0> struct In { template<class Event> static void process(Event const& evt,library_sm* self_,HandledEnum& result_) { // use this table as if it came directly from the user typedef dispatch_table<library_sm,complete_table,Event,CompilePolicy> table; // +1 because index 0 is reserved for this fsm HandledEnum res = table::instance.entries[self_->m_states[region_id::value]+1]( *self_, region_id::value , self_->m_states[region_id::value], evt); result_ = (HandledEnum)((int)result_ | (int)res); In< ::boost::mpl::int_<region_id::value+1> >::process(evt,self_,result_); } }; template <int Dummy> struct In< ::boost::mpl::int_<nr_regions::value>,Dummy> { // end of processing template<class Event> static void process(Event const& evt,library_sm* self_,HandledEnum& result_) { // process the event in the internal table of this fsm if the event is processable (present in the table) process_fsm_internal_table<Event>::process(evt,self_,result_); } }; public: region_processing_helper(library_sm* self_,HandledEnum& result_) :self(self_),result(result_){} template<class Event> void process(Event const& evt) { In< ::boost::mpl::int_<0> >::process(evt,self,result); } library_sm* self; HandledEnum& result; }; // Main function used internally to make transitions // Can only be called for internally (for example in an action method) generated events. template<class Event> execute_return process_event_internal(Event const& evt, EventSource source = EVENT_SOURCE_DEFAULT) { // if the state machine has terminate or interrupt flags, check them, otherwise skip if (is_event_handling_blocked_helper<Event> ( ::boost::mpl::bool_<has_fsm_blocking_states<library_sm>::type::value>() ) ) { return HANDLED_TRUE; } // if a message queue is needed and processing is on the way if (!do_pre_msg_queue_helper<Event> (evt,::boost::mpl::bool_<is_no_message_queue<library_sm>::type::value>())) { // wait for the end of current processing return HANDLED_TRUE; } else { // Process event HandledEnum handled = this->do_process_helper<Event>( evt, ::boost::mpl::bool_<is_no_exception_thrown<library_sm>::type::value>(), (EVENT_SOURCE_DIRECT & source)); // at this point we allow the next transition be executed without enqueing // so that completion events and deferred events execute now (if any) do_allow_event_processing_after_transition( ::boost::mpl::bool_<is_no_message_queue<library_sm>::type::value>()); // Process completion transitions BEFORE any other event in the // pool (UML Standard 2.3 15.3.14) handle_eventless_transitions_helper<library_sm> eventless_helper(this,(HANDLED_TRUE & handled)); eventless_helper.process_completion_event(source); // After handling, take care of the deferred events, but only if // we're not already processing from the deferred queue. do_handle_prio_msg_queue_deferred_queue( source,handled, ::boost::mpl::bool_<has_event_queue_before_deferred_queue<library_sm>::type::value>()); return handled; } } // minimum event processing without exceptions, queues, etc. template<class Event> HandledEnum do_process_event(Event const& evt, bool is_direct_call) { HandledEnum handled = HANDLED_FALSE; // dispatch the event to every region region_processing_helper<Derived> helper(this,handled); helper.process(evt); // if the event has not been handled and we have orthogonal zones, then // generate an error on every active state // for state machine states contained in other state machines, do not handle // but let the containing sm handle the error, unless the event was generated in this fsm // (by calling process_event on this fsm object, is_direct_call == true) // completion events do not produce an error if ( (!is_contained() || is_direct_call) && !handled && !is_completion_event<Event>::type::value) { for (int i=0; i<nr_regions::value;++i) { this->no_transition(evt,*this,this->m_states[i]); } } return handled; } // default row arguments for the compilers which accept this template <class Event> bool no_guard(Event const&){return true;} template <class Event> void no_action(Event const&){} #ifndef BOOST_NO_RTTI HandledEnum process_any_event( ::boost::any const& evt); #endif private: // composite accept implementation. First calls accept on the composite, then accept on all its active states. void composite_accept() { this->accept(); this->visit_current_states(); } #define MSM_COMPOSITE_ACCEPT_SUB(z, n, unused) ARG ## n vis ## n #define MSM_COMPOSITE_ACCEPT_SUB2(z, n, unused) boost::ref( vis ## n ) #define MSM_COMPOSITE_ACCEPT_EXECUTE(z, n, unused) \ template <BOOST_PP_ENUM_PARAMS(n, class ARG)> \ void composite_accept(BOOST_PP_ENUM(n, MSM_COMPOSITE_ACCEPT_SUB, ~ ) ) \ { \ this->accept(BOOST_PP_ENUM_PARAMS(n,vis)); \ this->visit_current_states(BOOST_PP_ENUM(n,MSM_COMPOSITE_ACCEPT_SUB2, ~)); \ } BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_ADD(BOOST_MSM_VISITOR_ARG_SIZE,1), MSM_COMPOSITE_ACCEPT_EXECUTE, ~) #undef MSM_COMPOSITE_ACCEPT_EXECUTE #undef MSM_COMPOSITE_ACCEPT_SUB #undef MSM_COMPOSITE_ACCEPT_SUB2 // helper used to call the init states at the start of the state machine template <class Event> struct call_init { call_init(Event const& an_event,library_sm* self_): evt(an_event),self(self_){} template <class State> void operator()(boost::msm::wrap<State> const&) { execute_entry(::boost::fusion::at_key<State>(self->m_substate_list),evt,*self); } private: Event const& evt; library_sm* self; }; // helper for flag handling. Uses OR by default on orthogonal zones. template <class Flag,bool orthogonalStates> struct FlagHelper { static bool helper(library_sm const& sm,flag_handler* ) { // by default we use OR to accumulate the flags return sm.is_flag_active<Flag,Flag_OR>(); } }; template <class Flag> struct FlagHelper<Flag,false> { static bool helper(library_sm const& sm,flag_handler* flags_entries) { // just one active state, so we can call operator[] with 0 return flags_entries[sm.current_state()[0]](sm); } }; // handling of flag // defines a true and false functions plus a forwarding one for composite states template <class StateType,class Flag> struct FlagHandler { static bool flag_true(library_sm const& ) { return true; } static bool flag_false(library_sm const& ) { return false; } static bool forward(library_sm const& fsm) { return ::boost::fusion::at_key<StateType>(fsm.m_substate_list).template is_flag_active<Flag>(); } }; template <class Flag> struct init_flags { private: // helper function, helps hiding the forward function for non-state machines states. template <class T> void helper (flag_handler* an_entry,int offset, ::boost::mpl::true_ const & ) { // composite => forward an_entry[offset] = &FlagHandler<T,Flag>::forward; } template <class T> void helper (flag_handler* an_entry,int offset, ::boost::mpl::false_ const & ) { // default no flag an_entry[offset] = &FlagHandler<T,Flag>::flag_false; } // attributes flag_handler* entries; public: init_flags(flag_handler* entries_) : entries(entries_) {} // Flags initializer function object, used with mpl::for_each template <class StateType> void operator()( ::boost::msm::wrap<StateType> const& ) { typedef typename get_flag_list<StateType>::type flags; typedef typename ::boost::mpl::contains<flags,Flag >::type found; BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,StateType>::type::value)); if (found::type::value) { // the type defined the flag => true entries[state_id] = &FlagHandler<StateType,Flag>::flag_true; } else { // false or forward typedef typename ::boost::mpl::and_< typename is_composite_state<StateType>::type, typename ::boost::mpl::not_< typename has_non_forwarding_flag<Flag>::type>::type >::type composite_no_forward; helper<StateType>(entries,state_id,::boost::mpl::bool_<composite_no_forward::type::value>()); } } }; // maintains for every flag a static array containing the flag value for every state template <class Flag> flag_handler* get_entries_for_flag() const { BOOST_STATIC_CONSTANT(int, max_state = (mpl::size<state_list>::value)); static flag_handler flags_entries[max_state]; // build a state list ::boost::mpl::for_each<state_list, boost::msm::wrap< ::boost::mpl::placeholders::_1> > (init_flags<Flag>(flags_entries)); return flags_entries; } // helper used to create a state using the correct constructor template <class State, class Enable=void> struct create_state_helper { static void set_sm(library_sm* ) { // state doesn't need its sm } }; // create a state requiring a pointer to the state machine template <class State> struct create_state_helper<State,typename boost::enable_if<typename State::needs_sm >::type> { static void set_sm(library_sm* sm) { // create and set the fsm ::boost::fusion::at_key<State>(sm->m_substate_list).set_sm_ptr(sm); } }; // main unspecialized helper class template <class StateType,int ARGS> struct visitor_args; #define MSM_VISITOR_ARGS_SUB(z, n, unused) BOOST_PP_CAT(::boost::placeholders::_,BOOST_PP_ADD(n,1)) #define MSM_VISITOR_ARGS_TYPEDEF_SUB(z, n, unused) typename StateType::accept_sig::argument ## n #define MSM_VISITOR_ARGS_EXECUTE(z, n, unused) \ template <class StateType> \ struct visitor_args<StateType,n> \ { \ template <class State> \ static typename enable_if_c<!is_composite_state<State>::value,void >::type \ helper (library_sm* sm, \ int id,StateType& astate) \ { \ sm->m_visitors.insert(id, boost::bind(&StateType::accept, \ ::boost::ref(astate) BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, MSM_VISITOR_ARGS_SUB, ~) )); \ } \ template <class State> \ static typename enable_if_c<is_composite_state<State>::value,void >::type \ helper (library_sm* sm, \ int id,StateType& astate) \ { \ void (StateType::*caccept)(BOOST_PP_ENUM(n, MSM_VISITOR_ARGS_TYPEDEF_SUB, ~ ) ) \ = &StateType::composite_accept; \ sm->m_visitors.insert(id, boost::bind(caccept, \ ::boost::ref(astate) BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, MSM_VISITOR_ARGS_SUB, ~) )); \ } \ }; BOOST_PP_REPEAT(BOOST_PP_ADD(BOOST_MSM_VISITOR_ARG_SIZE,1), MSM_VISITOR_ARGS_EXECUTE, ~) #undef MSM_VISITOR_ARGS_EXECUTE #undef MSM_VISITOR_ARGS_SUB // the IBM compiler seems to have problems with nested classes // the same seems to apply to the Apple version of gcc 4.0.1 (just in case we do for < 4.1) // and also to MS VC < 8 #if defined (__IBMCPP__) || (__GNUC__ == 4 && __GNUC_MINOR__ < 1) || (defined(_MSC_VER) && (_MSC_VER < 1400)) public: #endif template<class ContainingSM> void set_containing_sm(ContainingSM* sm) { m_is_included=true; ::boost::fusion::for_each(m_substate_list,add_state<ContainingSM>(this,sm)); } #if defined (__IBMCPP__) || (__GNUC__ == 4 && __GNUC_MINOR__ < 1) || (defined(_MSC_VER) && (_MSC_VER < 1400)) private: #endif // A function object for use with mpl::for_each that stuffs // states into the state list. template<class ContainingSM> struct add_state { add_state(library_sm* self_,ContainingSM* sm) : self(self_),containing_sm(sm){} // State is a sub fsm with exit pseudo states and gets a pointer to this fsm, so it can build a callback template <class StateType> typename ::boost::enable_if< typename is_composite_state<StateType>::type,void >::type new_state_helper(boost::msm::back::dummy<0> = 0) const { ::boost::fusion::at_key<StateType>(self->m_substate_list).set_containing_sm(containing_sm); } // State is a sub fsm without exit pseudo states and does not get a callback to this fsm // or state is a normal state and needs nothing except creation template <class StateType> typename ::boost::enable_if< typename boost::mpl::and_<typename boost::mpl::not_ <typename is_composite_state<StateType>::type>::type, typename boost::mpl::not_ <typename is_pseudo_exit<StateType>::type>::type >::type,void>::type new_state_helper( ::boost::msm::back::dummy<1> = 0) const { //nothing to do } // state is exit pseudo state and gets callback to target fsm template <class StateType> typename ::boost::enable_if<typename is_pseudo_exit<StateType>::type,void >::type new_state_helper( ::boost::msm::back::dummy<2> = 0) const { execute_return (ContainingSM::*pf) (typename StateType::event const& evt)= &ContainingSM::process_event; ::boost::function<execute_return (typename StateType::event const&)> fct = ::boost::bind(pf,containing_sm,::boost::placeholders::_1); ::boost::fusion::at_key<StateType>(self->m_substate_list).set_forward_fct(fct); } // for every defined state in the sm template <class State> void operator()( State const&) const { //create a new state with the defined id and type BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value)); this->new_state_helper<State>(), create_state_helper<State>::set_sm(self); // create a visitor callback visitor_helper(state_id,::boost::fusion::at_key<State>(self->m_substate_list), ::boost::mpl::bool_<has_accept_sig<State>::type::value>()); } private: // support possible use of a visitor if accept_sig is defined template <class StateType> void visitor_helper(int id,StateType& astate, ::boost::mpl::true_ const & ) const { visitor_args<StateType,StateType::accept_sig::args_number>:: template helper<StateType>(self,id,astate); } template <class StateType> void visitor_helper(int ,StateType& , ::boost::mpl::false_ const &) const { // nothing to do } library_sm* self; ContainingSM* containing_sm; }; // helper used to copy every state if needed struct copy_helper { copy_helper(library_sm* sm): m_sm(sm){} template <class StateType> void operator()( ::boost::msm::wrap<StateType> const& ) { BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,StateType>::type::value)); // possibly also set the visitor visitor_helper<StateType>(state_id); // and for states that keep a pointer to the fsm, reset the pointer create_state_helper<StateType>::set_sm(m_sm); } template <class StateType> typename ::boost::enable_if<typename has_accept_sig<StateType>::type,void >::type visitor_helper(int id) const { visitor_args<StateType,StateType::accept_sig::args_number>::template helper<StateType> (m_sm,id,::boost::fusion::at_key<StateType>(m_sm->m_substate_list)); } template <class StateType> typename ::boost::disable_if<typename has_accept_sig<StateType>::type,void >::type visitor_helper(int) const { // nothing to do } library_sm* m_sm; }; // helper to copy the active states attribute template <class region_id,int Dummy=0> struct region_copy_helper { static void do_copy(library_sm* self_,library_sm const& rhs) { self_->m_states[region_id::value] = rhs.m_states[region_id::value]; region_copy_helper< ::boost::mpl::int_<region_id::value+1> >::do_copy(self_,rhs); } }; template <int Dummy> struct region_copy_helper< ::boost::mpl::int_<nr_regions::value>,Dummy> { // end of processing static void do_copy(library_sm*,library_sm const& ){} }; // copy functions for deep copy (no need of a 2nd version for NoCopy as noncopyable handles it) void do_copy (library_sm const& rhs, ::boost::msm::back::dummy<0> = 0) { // deep copy simply assigns the data region_copy_helper< ::boost::mpl::int_<0> >::do_copy(this,rhs); m_events_queue = rhs.m_events_queue; m_deferred_events_queue = rhs.m_deferred_events_queue; m_history = rhs.m_history; m_event_processing = rhs.m_event_processing; m_is_included = rhs.m_is_included; m_substate_list = rhs.m_substate_list; // except for the states themselves, which get duplicated ::boost::mpl::for_each<state_list, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > (copy_helper(this)); } // helper used to call the correct entry/exit method // unfortunately in O(number of states in the sub-sm) but should be better than a virtual call template<class Event,bool is_entry> struct entry_exit_helper { entry_exit_helper(int id,Event const& e,library_sm* self_): state_id(id),evt(e),self(self_){} // helper for entry actions template <class IsEntry,class State> typename ::boost::enable_if<typename IsEntry::type,void >::type helper( ::boost::msm::back::dummy<0> = 0) { BOOST_STATIC_CONSTANT(int, id = (get_state_id<stt,State>::value)); if (id == state_id) { execute_entry<State>(::boost::fusion::at_key<State>(self->m_substate_list),evt,*self); } } // helper for exit actions template <class IsEntry,class State> typename boost::disable_if<typename IsEntry::type,void >::type helper( ::boost::msm::back::dummy<1> = 0) { BOOST_STATIC_CONSTANT(int, id = (get_state_id<stt,State>::value)); if (id == state_id) { execute_exit<State>(::boost::fusion::at_key<State>(self->m_substate_list),evt,*self); } } // iterates through all states to find the one to be activated template <class State> void operator()( ::boost::msm::wrap<State> const&) { entry_exit_helper<Event,is_entry>::template helper< ::boost::mpl::bool_<is_entry>,State >(); } private: int state_id; Event const& evt; library_sm* self; }; // helper to start the fsm template <class region_id,int Dummy=0> struct region_start_helper { template<class Event> static void do_start(library_sm* self_,Event const& incomingEvent) { //forward the event for handling by sub state machines ::boost::mpl::for_each<state_list, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > (entry_exit_helper<Event,true>(self_->m_states[region_id::value],incomingEvent,self_)); region_start_helper < ::boost::mpl::int_<region_id::value+1> >::do_start(self_,incomingEvent); } }; template <int Dummy> struct region_start_helper< ::boost::mpl::int_<nr_regions::value>,Dummy> { // end of processing template<class Event> static void do_start(library_sm*,Event const& ){} }; // start for states machines which are themselves embedded in other state machines (composites) template <class Event> void internal_start(Event const& incomingEvent) { region_start_helper< ::boost::mpl::int_<0> >::do_start(this,incomingEvent); // give a chance to handle an anonymous (eventless) transition handle_eventless_transitions_helper<library_sm> eventless_helper(this,true); eventless_helper.process_completion_event(); } template <class StateType> struct find_region_id { template <int region,int Dummy=0> struct In { enum {region_index=region}; }; // if the user provides no region, find it! template<int Dummy> struct In<-1,Dummy> { typedef typename build_orthogonal_regions< library_sm, initial_states >::type all_regions; enum {region_index= find_region_index<all_regions,StateType>::value }; }; enum {region_index = In<StateType::zone_index>::region_index }; }; // helper used to set the correct state as active state upon entry into a fsm struct direct_event_start_helper { direct_event_start_helper(library_sm* self_):self(self_){} // this variant is for the standard case, entry due to activation of the containing FSM template <class EventType,class FsmType> typename ::boost::disable_if<typename has_direct_entry<EventType>::type,void>::type operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<0> = 0) { (static_cast<Derived*>(self))->on_entry(evt,fsm); self->internal_start(evt); } // this variant is for the direct entry case (just one entry, not a sequence of entries) template <class EventType,class FsmType> typename ::boost::enable_if< typename ::boost::mpl::and_< typename ::boost::mpl::not_< typename is_pseudo_entry< typename EventType::active_state>::type >::type, typename ::boost::mpl::and_<typename has_direct_entry<EventType>::type, typename ::boost::mpl::not_<typename ::boost::mpl::is_sequence <typename EventType::active_state>::type >::type >::type>::type,void >::type operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<1> = 0) { (static_cast<Derived*>(self))->on_entry(evt,fsm); int state_id = get_state_id<stt,typename EventType::active_state::wrapped_entry>::value; BOOST_STATIC_ASSERT(find_region_id<typename EventType::active_state::wrapped_entry>::region_index >= 0); BOOST_STATIC_ASSERT(find_region_id<typename EventType::active_state::wrapped_entry>::region_index < nr_regions::value); // just set the correct zone, the others will be default/history initialized self->m_states[find_region_id<typename EventType::active_state::wrapped_entry>::region_index] = state_id; self->internal_start(evt.m_event); } // this variant is for the fork entry case (a sequence on entries) template <class EventType,class FsmType> typename ::boost::enable_if< typename ::boost::mpl::and_< typename ::boost::mpl::not_< typename is_pseudo_entry<typename EventType::active_state>::type >::type, typename ::boost::mpl::and_<typename has_direct_entry<EventType>::type, typename ::boost::mpl::is_sequence< typename EventType::active_state>::type >::type>::type,void >::type operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<2> = 0) { (static_cast<Derived*>(self))->on_entry(evt,fsm); ::boost::mpl::for_each<typename EventType::active_state, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > (fork_helper<EventType>(self,evt)); // set the correct zones, the others (if any) will be default/history initialized self->internal_start(evt.m_event); } // this variant is for the pseudo state entry case template <class EventType,class FsmType> typename ::boost::enable_if< typename is_pseudo_entry<typename EventType::active_state >::type,void >::type operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<3> = 0) { // entry on the FSM (static_cast<Derived*>(self))->on_entry(evt,fsm); int state_id = get_state_id<stt,typename EventType::active_state::wrapped_entry>::value; BOOST_STATIC_ASSERT(find_region_id<typename EventType::active_state::wrapped_entry>::region_index >= 0); BOOST_STATIC_ASSERT(find_region_id<typename EventType::active_state::wrapped_entry>::region_index < nr_regions::value); // given region starts with the entry pseudo state as active state self->m_states[find_region_id<typename EventType::active_state::wrapped_entry>::region_index] = state_id; self->internal_start(evt.m_event); // and we process the transition in the zone of the newly active state // (entry pseudo states are, according to UML, a state connecting 1 transition outside to 1 inside self->process_event(evt.m_event); } private: // helper for the fork case, does almost like the direct entry library_sm* self; template <class EventType> struct fork_helper { fork_helper(library_sm* self_,EventType const& evt_): helper_self(self_),helper_evt(evt_){} template <class StateType> void operator()( ::boost::msm::wrap<StateType> const& ) { int state_id = get_state_id<stt,typename StateType::wrapped_entry>::value; BOOST_STATIC_ASSERT(find_region_id<typename StateType::wrapped_entry>::region_index >= 0); BOOST_STATIC_ASSERT(find_region_id<typename StateType::wrapped_entry>::region_index < nr_regions::value); helper_self->m_states[find_region_id<typename StateType::wrapped_entry>::region_index] = state_id; } private: library_sm* helper_self; EventType const& helper_evt; }; }; // helper for entry template <class region_id,int Dummy=0> struct region_entry_exit_helper { template<class Event> static void do_entry(library_sm* self_,Event const& incomingEvent) { self_->m_states[region_id::value] = self_->m_history.history_entry(incomingEvent)[region_id::value]; region_entry_exit_helper < ::boost::mpl::int_<region_id::value+1> >::do_entry(self_,incomingEvent); } template<class Event> static void do_exit(library_sm* self_,Event const& incomingEvent) { ::boost::mpl::for_each<state_list, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > (entry_exit_helper<Event,false>(self_->m_states[region_id::value],incomingEvent,self_)); region_entry_exit_helper < ::boost::mpl::int_<region_id::value+1> >::do_exit(self_,incomingEvent); } }; template <int Dummy> struct region_entry_exit_helper< ::boost::mpl::int_<nr_regions::value>,Dummy> { // end of processing template<class Event> static void do_entry(library_sm*,Event const& ){} template<class Event> static void do_exit(library_sm*,Event const& ){} }; // entry/exit for states machines which are themselves embedded in other state machines (composites) template <class Event,class FsmType> void do_entry(Event const& incomingEvent,FsmType& fsm) { // by default we activate the history/init states, can be overwritten by direct_event_start_helper region_entry_exit_helper< ::boost::mpl::int_<0> >::do_entry(this,incomingEvent); // block immediate handling of events m_event_processing = true; // if the event is generating a direct entry/fork, set the current state(s) to the direct state(s) direct_event_start_helper(this)(incomingEvent,fsm); // handle messages which were generated and blocked in the init calls m_event_processing = false; // look for deferred events waiting handle_defer_helper<library_sm> defer_helper(m_deferred_events_queue); defer_helper.do_handle_deferred(true); process_message_queue(this); } template <class Event,class FsmType> void do_exit(Event const& incomingEvent,FsmType& fsm) { // first recursively exit the sub machines // forward the event for handling by sub state machines region_entry_exit_helper< ::boost::mpl::int_<0> >::do_exit(this,incomingEvent); // then call our own exit (static_cast<Derived*>(this))->on_exit(incomingEvent,fsm); // give the history a chance to handle this (or not). m_history.history_exit(this->m_states); // history decides what happens with deferred events if (!m_history.process_deferred_events(incomingEvent)) { clear_deferred_queue(); } } // the IBM and VC<8 compilers seem to have problems with the friend declaration of dispatch_table #if defined (__IBMCPP__) || (defined(_MSC_VER) && (_MSC_VER < 1400)) public: #endif // no transition for event. template <class Event> static HandledEnum call_no_transition(library_sm& , int , int , Event const& ) { return HANDLED_FALSE; } // no transition for event for internal transitions (not an error). template <class Event> static HandledEnum call_no_transition_internal(library_sm& , int , int , Event const& ) { //// reject to give others a chance to handle //return HANDLED_GUARD_REJECT; return HANDLED_FALSE; } // called for deferred events. Address set in the dispatch_table at init template <class Event> static HandledEnum defer_transition(library_sm& fsm, int , int , Event const& e) { fsm.defer_event(e); return HANDLED_DEFERRED; } // called for completion events. Default address set in the dispatch_table at init // prevents no-transition detection for completion events template <class Event> static HandledEnum default_eventless_transition(library_sm&, int, int , Event const&) { return HANDLED_FALSE; } #if defined (__IBMCPP__) || (defined(_MSC_VER) && (_MSC_VER < 1400)) private: #endif // removes one event from the message queue and processes it template <class StateType> void process_message_queue(StateType*, typename ::boost::disable_if<typename is_no_message_queue<StateType>::type,void >::type* = 0) { // Iteratively process all events from the message queue. while (!m_events_queue.m_events_queue.empty()) { transition_fct next = m_events_queue.m_events_queue.front(); m_events_queue.m_events_queue.pop_front(); next(); } } template <class StateType> void process_message_queue(StateType*, typename ::boost::enable_if<typename is_no_message_queue<StateType>::type,void >::type* = 0) { // nothing to process } // helper function. In cases where the event is wrapped (target is a direct entry states) // we want to send only the real event to on_entry, not the wrapper. template <class EventType> static typename boost::enable_if<typename has_direct_entry<EventType>::type,typename EventType::contained_event const& >::type remove_direct_entry_event_wrapper(EventType const& evt,boost::msm::back::dummy<0> = 0) { return evt.m_event; } template <class EventType> static typename boost::disable_if<typename has_direct_entry<EventType>::type,EventType const& >::type remove_direct_entry_event_wrapper(EventType const& evt,boost::msm::back::dummy<1> = 0) { // identity. No wrapper return evt; } // calls the entry/exit or on_entry/on_exit depending on the state type // (avoids calling virtually) // variant for FSMs template <class StateType,class EventType,class FsmType> static typename boost::enable_if<typename is_composite_state<StateType>::type,void >::type execute_entry(StateType& astate,EventType const& evt,FsmType& fsm,boost::msm::back::dummy<0> = 0) { // calls on_entry on the fsm then handles direct entries, fork, entry pseudo state astate.do_entry(evt,fsm); } // variant for states template <class StateType,class EventType,class FsmType> static typename ::boost::disable_if< typename ::boost::mpl::or_<typename is_composite_state<StateType>::type, typename is_pseudo_exit<StateType>::type >::type,void >::type execute_entry(StateType& astate,EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<1> = 0) { // simple call to on_entry astate.on_entry(remove_direct_entry_event_wrapper(evt),fsm); } // variant for exit pseudo states template <class StateType,class EventType,class FsmType> static typename ::boost::enable_if<typename is_pseudo_exit<StateType>::type,void >::type execute_entry(StateType& astate,EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<2> = 0) { // calls on_entry on the state then forward the event to the transition which should be defined inside the // contained fsm astate.on_entry(evt,fsm); astate.forward_event(evt); } template <class StateType,class EventType,class FsmType> static typename ::boost::enable_if<typename is_composite_state<StateType>::type,void >::type execute_exit(StateType& astate,EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<0> = 0) { astate.do_exit(evt,fsm); } template <class StateType,class EventType,class FsmType> static typename ::boost::disable_if<typename is_composite_state<StateType>::type,void >::type execute_exit(StateType& astate,EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<1> = 0) { // simple call to on_exit astate.on_exit(evt,fsm); } // helper allowing special handling of direct entries / fork template <class StateType,class TargetType,class EventType,class FsmType> static typename ::boost::disable_if< typename ::boost::mpl::or_<typename has_explicit_entry_state<TargetType>::type, ::boost::mpl::is_sequence<TargetType> >::type,void>::type convert_event_and_execute_entry(StateType& astate,EventType const& evt, FsmType& fsm, ::boost::msm::back::dummy<1> = 0) { // if the target is a normal state, do the standard entry handling execute_entry<StateType>(astate,evt,fsm); } template <class StateType,class TargetType,class EventType,class FsmType> static typename ::boost::enable_if< typename ::boost::mpl::or_<typename has_explicit_entry_state<TargetType>::type, ::boost::mpl::is_sequence<TargetType> >::type,void >::type convert_event_and_execute_entry(StateType& astate,EventType const& evt, FsmType& fsm, ::boost::msm::back::dummy<0> = 0) { // for the direct entry, pack the event in a wrapper so that we handle it differently during fsm entry execute_entry(astate,msm::back::direct_entry_event<TargetType,EventType>(evt),fsm); } // creates all the states template <class ContainingSM> void fill_states(ContainingSM* containing_sm=0) { // checks that regions are truly orthogonal FsmCheckPolicy::template check_orthogonality<library_sm>(); // checks that all states are reachable FsmCheckPolicy::template check_unreachable_states<library_sm>(); BOOST_STATIC_CONSTANT(int, max_state = (mpl::size<state_list>::value)); // allocate the place without reallocation m_visitors.fill_visitors(max_state); ::boost::fusion::for_each(m_substate_list,add_state<ContainingSM>(this,containing_sm)); } private: template <class StateType,class Enable=void> struct msg_queue_helper { public: msg_queue_helper():m_events_queue(){} events_queue_t m_events_queue; }; template <class StateType> struct msg_queue_helper<StateType, typename ::boost::enable_if<typename is_no_message_queue<StateType>::type >::type> { }; template <class Fsm,class Stt, class Event, class Compile> friend struct dispatch_table; // data members int m_states[nr_regions::value]; msg_queue_helper<library_sm> m_events_queue; deferred_msg_queue_helper <library_sm> m_deferred_events_queue; concrete_history m_history; bool m_event_processing; bool m_is_included; visitor_fct_helper<BaseState> m_visitors; substate_list m_substate_list; }; } } }// boost::msm::back #endif //BOOST_MSM_BACK_STATEMACHINE_H PK �!\p}h�. . history_policies.hppnu �[��� // 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; } // this policy deletes all waiting deferred events template <class Event> bool process_deferred_events(Event const&)const { return false; } 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; } // the history policy keeps all deferred events until next reentry template <class Event> bool process_deferred_events(Event const&)const { return true; } 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; } // the history policy keeps deferred events until next reentry if coming from our history event template <class Event> bool process_deferred_events(Event const&)const { return ::boost::mpl::contains<Events,Event>::value; } 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 PK �!\�FU%6 6 favor_compile_time.hppnu �[��� // 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_internal(::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 && res != HANDLED_DEFERRED )) { 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 , int , 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 PK �!\�7�� � common_types.hppnu �[��� // 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; // source of event provided to RTC algorithm enum EventSourceEnum { EVENT_SOURCE_DEFAULT=0, EVENT_SOURCE_DIRECT=1, EVENT_SOURCE_DEFERRED=2, EVENT_SOURCE_MSG_QUEUE=4 }; typedef unsigned char EventSource; }}} #endif //BOOST_MSM_COMMON_TYPES_H PK �!\�4a5Q Q copy_policies.hppnu �[��� // 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 PK �!\ �1�� � queue_container_circular.hppnu �[��� // 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 PK �!\'%&� � args.hppnu �[��� // 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 PK �!\=�3%� � queue_container_deque.hppnu �[��� // 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 PK �!\Dmd6g g mpl_graph_fsm_check.hppnu �[��� // 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 PK �!\*Kj�r r bind_helpers.hppnu �[��� // 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 { typedef _Ty first_argument_type; typedef _Tz second_argument_type; typedef _Ty result_type; // 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 PK �!\�)��X X default_compile_policy.hppnu �[��� // 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 PK �!\\w9�O �O dispatch_table.hppnu �[��� // 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/type_traits/is_same.hpp> #include <boost/msm/event_traits.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 && HANDLED_DEFERRED!=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)); template <class Transition> struct convert_event_and_forward { static HandledEnum execute(Fsm& fsm, int region_index, int state, Event const& evt) { typename Transition::transition_event forwarded(evt); return Transition::execute(fsm,region_index,state,forwarded); } }; // 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 &, ::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] = 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 &, ::boost::mpl::false_ const &) const { self->entries[0] = reinterpret_cast<cell>(&Transition::execute); } // version for transition event is boost::any // 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 &, ::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] = &convert_event_and_forward<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 &, ::boost::mpl::true_ const &) const { self->entries[0] = &convert_event_and_forward<Transition>::execute; } 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 &, ::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] = &convert_event_and_forward<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 &, ::boost::mpl::true_ const &) const { self->entries[0] = &convert_event_and_forward<Transition>::execute; } // end version for kleene // 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 &, ::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 &, ::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>(), ::boost::mpl::bool_< ::boost::msm::is_kleene_event<typename Transition::transition_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! // case for internal transitions of this fsm template <class State> typename ::boost::disable_if< typename ::boost::is_same<State,Fsm>::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::default_eventless_transition; tofill_entries[state_id+1] = call_no_transition; } template <class State> typename ::boost::enable_if< typename ::boost::is_same<State,Fsm>::type ,void>::type operator()(boost::msm::wrap<State> const&,boost::msm::back::dummy<1> = 0) { cell call_no_transition = &Fsm::default_eventless_transition; tofill_entries[0] = 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::mpl::or_< ::boost::is_base_of<transition_event< ::boost::mpl::placeholders::_>, Event>, ::boost::msm::is_kleene_event<transition_event< ::boost::mpl::placeholders::_> > > >, // 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 PK �!\i9kL� � fold_to_list.hppnu �[��� // 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 PK �!\f�z�-� -� metafunctions.hppnu �[��� // 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 <algorithm> #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> #include <boost/msm/row_tags.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; }; // builds flags (add internal_flag_list and flag_list). internal_flag_list is used for terminate/interrupt states template <class StateType> struct get_flag_list { typedef typename ::boost::mpl::insert_range< typename StateType::flag_list, typename ::boost::mpl::end< typename StateType::flag_list >::type, typename StateType::internal_flag_list >::type type; }; template <class StateType> struct is_state_blocking { typedef typename ::boost::mpl::fold< typename get_flag_list<StateType>::type, ::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; } // transformation metafunction to end interrupt flags template <class Event> struct transform_to_end_interrupt { typedef boost::msm::EndInterruptFlag<Event> type; }; // transform a sequence of events into another one of EndInterruptFlag<Event> template <class Events> struct apply_end_interrupt_flag { typedef typename ::boost::mpl::transform< Events,transform_to_end_interrupt< ::boost::mpl::placeholders::_1> >::type type; }; // returns a mpl vector containing all end interrupt events if sequence, otherwise the same event template <class Event> struct get_interrupt_events { typedef typename ::boost::mpl::eval_if< ::boost::mpl::is_sequence<Event>, boost::msm::back::apply_end_interrupt_flag<Event>, boost::mpl::vector1<boost::msm::EndInterruptFlag<Event> > >::type type; }; template <class Events> struct build_interrupt_state_flag_list { typedef ::boost::mpl::vector<boost::msm::InterruptedFlag> first_part; typedef typename ::boost::mpl::insert_range< first_part, typename ::boost::mpl::end< first_part >::type, Events >::type type; }; } } }//boost::msm::back #endif // BOOST_MSM_BACK_METAFUNCTIONS_H PK �!\/(�/ no_fsm_check.hppnu �[��� PK �!\���R� � S tools.hppnu �[��� PK �!\O�C�� �� q state_machine.hppnu �[��� PK �!\p}h�. . l� history_policies.hppnu �[��� PK �!\�FU%6 6 � favor_compile_time.hppnu �[��� PK �!\�7�� � 'A common_types.hppnu �[��� PK �!\�4a5Q Q F copy_policies.hppnu �[��� PK �!\ �1�� � �I queue_container_circular.hppnu �[��� PK �!\'%&� � �M args.hppnu �[��� PK �!\=�3%� � �[ queue_container_deque.hppnu �[��� PK �!\Dmd6g g �_ mpl_graph_fsm_check.hppnu �[��� PK �!\*Kj�r r �g bind_helpers.hppnu �[��� PK �!\�)��X X Jm default_compile_policy.hppnu �[��� PK �!\\w9�O �O �p dispatch_table.hppnu �[��� PK �!\i9kL� � �� fold_to_list.hppnu �[��� PK �!\f�z�-� -� s� metafunctions.hppnu �[��� PK & �U
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0 |
proxy
|
phpinfo
|
???????????