| // Copyright 2008 Christophe Henry |
| // henry UNDERSCORE christophe AT hotmail DOT com |
| // This is an extended version of the state machine available in the boost::mpl library |
| // Distributed under the same license as the original. |
| // Copyright for the original version: |
| // Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed |
| // under the Boost Software License, Version 1.0. (See accompanying |
| // file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| |
| #ifndef BOOST_MSM_FRONT_EUML_COMMON_H |
| #define BOOST_MSM_FRONT_EUML_COMMON_H |
| |
| #include <boost/config.hpp> |
| #include <boost/msm/proto_config.hpp> |
| |
| #ifndef BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS |
| #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS |
| #endif |
| |
| #include <iterator> |
| #include <utility> |
| |
| #include <boost/proto/core.hpp> |
| #include <boost/proto/transform.hpp> |
| |
| #include <boost/utility/enable_if.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #include <boost/type_traits/remove_reference.hpp> |
| #include <boost/type_traits/add_const.hpp> |
| |
| #include <boost/mpl/vector.hpp> |
| #include <boost/mpl/set.hpp> |
| #include <boost/mpl/has_key.hpp> |
| #include <boost/mpl/int.hpp> |
| #include <boost/mpl/less_equal.hpp> |
| |
| #if BOOST_VERSION >= 104000 |
| #include <boost/mpl/string.hpp> |
| #endif |
| |
| #include <boost/fusion/container/vector.hpp> |
| #include <boost/fusion/include/at_c.hpp> |
| #include <boost/fusion/include/make_map.hpp> |
| #include <boost/fusion/include/pair.hpp> |
| #include <boost/fusion/include/as_vector.hpp> |
| #include <boost/fusion/include/pair.hpp> |
| #include <boost/fusion/include/is_sequence.hpp> |
| |
| #include <boost/type_traits/remove_reference.hpp> |
| |
| #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/preprocessor/repetition/repeat_from_to.hpp> |
| #include <boost/preprocessor/cat.hpp> |
| #include <boost/msm/front/functor_row.hpp> |
| |
| namespace proto = boost::proto; |
| |
| BOOST_MPL_HAS_XXX_TRAIT_DEF(tag_type) |
| BOOST_MPL_HAS_XXX_TRAIT_DEF(action_name) |
| |
| namespace boost { namespace msm { namespace front { namespace euml |
| { |
| template <class T> |
| struct get_iterator |
| { |
| typedef typename T::iterator type; |
| }; |
| template <class T> |
| struct get_reverse_iterator |
| { |
| typedef typename T::reverse_iterator type; |
| }; |
| template <class T> |
| struct get_reference |
| { |
| typedef typename T::reference type; |
| }; |
| template <class T> |
| struct get_size_type |
| { |
| typedef typename T::size_type type; |
| }; |
| template <class T> |
| struct get_value_type |
| { |
| typedef typename T::value_type type; |
| }; |
| template <class T> |
| struct get_first_type |
| { |
| typedef typename T::first_type type; |
| }; |
| template <class T> |
| struct get_second_type |
| { |
| typedef typename T::second_type type; |
| }; |
| template <class T> |
| struct get_action_tag_type |
| { |
| typedef typename ::boost::mpl::has_key< |
| typename T::tag_type,action_tag>::type type; |
| }; |
| template <class T> |
| struct get_state_action_tag_type |
| { |
| typedef typename ::boost::mpl::has_key< |
| typename T::tag_type,state_action_tag>::type type; |
| }; |
| |
| template <class T,class EVT,class FSM,class SourceState,class TargetState> |
| struct get_result_type |
| { |
| typedef typename T::template transition_action_result<EVT,FSM,SourceState,TargetState>::type type; |
| }; |
| template <class T,class Event,class FSM,class STATE> |
| struct get_result_type2 |
| { |
| typedef typename T::template state_action_result<Event,FSM,STATE>::type type; |
| }; |
| template<class SEQ> |
| struct get_sequence |
| { |
| typedef typename SEQ::sequence type; |
| }; |
| |
| template <class T> |
| struct get_attributes_type |
| { |
| typedef typename T::attributes_type type; |
| }; |
| |
| template <class T> |
| struct get_euml_tag_type |
| { |
| typedef typename T::euml_tag_type type; |
| }; |
| |
| template <class T,class Arg1=void,class Arg2=void,class Arg3=void,class Arg4=void,class Arg5=void |
| #ifdef BOOST_MSVC |
| ,class Arg6=void |
| #endif |
| > |
| struct get_fct |
| { |
| typedef typename T::template In<Arg1,Arg2,Arg3,Arg4,Arg5 |
| #ifdef BOOST_MSVC |
| ,Arg6 |
| #endif |
| >::type type; |
| }; |
| |
| template <class T> |
| struct get_action_name |
| { |
| typedef typename T::action_name type; |
| }; |
| template <class T> |
| struct get_event_name |
| { |
| typedef typename T::event_name type; |
| }; |
| |
| // grammar forbidding address of for terminals |
| struct terminal_grammar : proto::not_<proto::address_of<proto::_> > |
| {}; |
| |
| // Forward-declare an expression wrapper |
| template<typename Expr> |
| struct euml_terminal; |
| |
| struct sm_domain |
| : proto::domain< proto::generator<euml_terminal>, terminal_grammar > |
| {}; |
| |
| struct state_grammar : |
| proto::and_< |
| proto::not_<proto::address_of<proto::_> >, |
| proto::not_<proto::shift_right<proto::_,proto::_> >, |
| proto::not_<proto::shift_left<proto::_,proto::_> >, |
| proto::not_<proto::bitwise_and<proto::_,proto::_> > |
| > |
| {}; |
| struct state_domain |
| : proto::domain< proto::generator<euml_terminal>, state_grammar,sm_domain > |
| {}; |
| |
| template<typename Expr> |
| struct euml_terminal |
| : proto::extends<Expr, euml_terminal<Expr>, sm_domain> |
| { |
| typedef |
| proto::extends<Expr, euml_terminal<Expr>, sm_domain> |
| base_type; |
| // Needs a constructor |
| euml_terminal(Expr const &e = Expr()) |
| : base_type(e) |
| {} |
| // Unhide Proto's overloaded assignment operator |
| using base_type::operator=; |
| }; |
| |
| template <class EVT> |
| struct euml_event: proto::extends<typename proto::terminal<event_tag>::type, EVT, sm_domain> |
| { |
| typedef event_tag euml_tag_type; |
| typedef EVT event_name; |
| using proto::extends<typename proto::terminal<event_tag>::type, EVT, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef EVT type; |
| }; |
| }; |
| template <class STATE> |
| struct euml_state: proto::extends<typename proto::terminal<state_tag>::type, STATE, state_domain> |
| { |
| typedef state_tag euml_tag_type; |
| using proto::extends<typename proto::terminal<state_tag>::type, STATE, state_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef STATE type; |
| }; |
| }; |
| template <class ACTION> |
| struct euml_action: proto::extends<typename proto::terminal<action_tag>::type, ACTION, sm_domain> |
| { |
| typedef action_tag euml_tag_type; |
| typedef ACTION action_name; |
| using proto::extends<typename proto::terminal<action_tag>::type, ACTION, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef ACTION type; |
| }; |
| }; |
| template <class FLAG> |
| struct euml_flag: proto::extends<typename proto::terminal<flag_tag>::type, FLAG, sm_domain> |
| { |
| typedef flag_tag euml_tag_type; |
| using proto::extends<typename proto::terminal<flag_tag>::type, FLAG, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef FLAG type; |
| }; |
| }; |
| |
| template <class CONFIG> |
| struct euml_config: proto::extends<typename proto::terminal<config_tag>::type, CONFIG, sm_domain> |
| { |
| typedef config_tag euml_tag_type; |
| using proto::extends<typename proto::terminal<config_tag>::type, CONFIG, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef CONFIG type; |
| }; |
| }; |
| |
| struct No_Exception : euml_config<No_Exception> |
| { |
| typedef int no_exception_thrown; |
| No_Exception(){} |
| }; |
| struct No_Msg_Queue : euml_config<No_Msg_Queue> |
| { |
| typedef int no_message_queue; |
| No_Msg_Queue(){} |
| }; |
| struct Deferred_Events : euml_config<Deferred_Events> |
| { |
| typedef int activate_deferred_events; |
| Deferred_Events(){} |
| }; |
| No_Exception const no_exception; |
| No_Msg_Queue const no_msg_queue; |
| Deferred_Events const deferred_events; |
| |
| struct invalid_type{}; |
| struct make_invalid_type |
| { |
| typedef invalid_type type; |
| }; |
| |
| template <class ROW> |
| struct make_vector_one_row |
| { |
| typedef boost::mpl::vector<ROW> type; |
| }; |
| template <class T> |
| T make_T(T t) {return t;} |
| |
| struct make_vector_no_row |
| { |
| typedef boost::mpl::vector0<> type; |
| }; |
| |
| struct NoAction : euml_action<NoAction> |
| { |
| NoAction(){} |
| // return value if used inside a state action (entry/exit) |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef bool type; |
| }; |
| // return value if used inside a transition (action/guard) |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef bool type; |
| }; |
| // this functor can be used in both modes, state action and transition action |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| bool operator()(Event const&,FSM&,STATE& ) |
| { |
| // does nothing |
| return true; |
| } |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| bool operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const |
| { |
| // does nothing |
| return true; |
| } |
| }; |
| NoAction const no_action; |
| |
| struct fsm_artefact_tag {}; |
| template <class Index=void> |
| struct GetSource_ : euml_action<GetSource_<Index> > |
| { |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename ::boost::fusion::result_of::at_key<typename SourceState::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& ,FSM& ,SourceState& src,TargetState&)const |
| { |
| return src.get_attribute(Index()); |
| } |
| }; |
| template<> |
| struct GetSource_<void> : euml_action<GetSource_<void> > |
| { |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef SourceState& type; |
| }; |
| typedef ::boost::mpl::set<action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& , FSM&,SourceState& src,TargetState& )const |
| { |
| return src; |
| } |
| }; |
| struct GetSource_Helper: proto::extends< proto::terminal<fsm_artefact_tag>::type, GetSource_Helper, sm_domain> |
| { |
| GetSource_Helper(){} |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef GetSource_<Arg1> type; |
| }; |
| }; |
| GetSource_Helper const source_; |
| |
| template <class Index=void> |
| struct GetTarget_ : euml_action<GetTarget_<Index> > |
| { |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename ::boost::fusion::result_of::at_key<typename TargetState::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& ,FSM& ,SourceState& ,TargetState& tgt)const |
| { |
| return tgt.get_attribute(Index()); |
| } |
| }; |
| template<> |
| struct GetTarget_<void> : euml_action<GetTarget_<void> > |
| { |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef TargetState& type; |
| }; |
| typedef ::boost::mpl::set<action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& , FSM&,SourceState& ,TargetState& tgt)const |
| { |
| return tgt; |
| } |
| }; |
| struct GetTarget_Helper: proto::extends< proto::terminal<fsm_artefact_tag>::type, GetTarget_Helper, sm_domain> |
| { |
| GetTarget_Helper(){} |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef GetTarget_<Arg1> type; |
| }; |
| }; |
| GetTarget_Helper const target_; |
| |
| template <class Index=void> |
| struct GetState_ : euml_action<GetState_<Index> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef typename ::boost::fusion::result_of::at_key<typename STATE::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const&,FSM& ,STATE& state ) |
| { |
| return state.get_attribute(Index()); |
| } |
| }; |
| template<> |
| struct GetState_<void> : euml_action<GetState_<void> > |
| { |
| using euml_action<GetState_ >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef STATE& type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const&,FSM& ,STATE& state ) |
| { |
| return state; |
| } |
| }; |
| struct GetState_Helper: proto::extends< proto::terminal<fsm_artefact_tag>::type, GetState_Helper, sm_domain> |
| { |
| GetState_Helper(){} |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef GetState_<Arg1> type; |
| }; |
| }; |
| GetState_Helper const state_; |
| |
| template <class Index=void> |
| struct GetEvent_ : euml_action<GetEvent_<Index> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef typename ::boost::add_const< |
| typename ::boost::fusion::result_of::at_key<typename Event::attributes_type, |
| Index >::type>::type type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename ::boost::add_const< |
| typename ::boost::fusion::result_of::at_key<typename EVT::attributes_type, |
| Index >::type>::type type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const& evt,FSM& ,STATE& ) |
| { |
| return evt.get_attribute(Index()); |
| } |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const |
| { |
| return evt.get_attribute(Index()); |
| } |
| }; |
| template <> |
| struct GetEvent_<void> : euml_action<GetEvent_<void> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef Event const& type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef EVT const& type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const& evt,FSM& ,STATE& ) |
| { |
| return evt; |
| } |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const |
| { |
| return evt; |
| } |
| }; |
| struct GetEvent_Helper: proto::extends< proto::terminal<fsm_artefact_tag>::type, GetEvent_Helper, sm_domain> |
| { |
| GetEvent_Helper(){} |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef GetEvent_<Arg1> type; |
| }; |
| }; |
| GetEvent_Helper const event_; |
| |
| template <class Index=void> |
| struct GetFsm_ : euml_action<GetFsm_<Index> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef typename ::boost::fusion::result_of::at_key<typename FSM::attributes_type, |
| Index >::type type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename ::boost::fusion::result_of::at_key<typename FSM::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const&,FSM& fsm,STATE& ) |
| { |
| return fsm.get_attribute(Index()); |
| } |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState&)const |
| { |
| return fsm.get_attribute(Index()); |
| } |
| }; |
| template<> |
| struct GetFsm_<void> : euml_action<GetFsm_<void> > |
| { |
| using euml_action<GetFsm_>::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef FSM& type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef FSM& type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const&,FSM& fsm,STATE& ) |
| { |
| return fsm; |
| } |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& evt ,FSM& fsm,SourceState& ,TargetState&)const |
| { |
| return fsm; |
| } |
| }; |
| struct GetFsm_Helper: proto::extends< proto::terminal<fsm_artefact_tag>::type, GetFsm_Helper, sm_domain> |
| { |
| GetFsm_Helper(){} |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef GetFsm_<Arg1> type; |
| }; |
| }; |
| GetFsm_Helper const fsm_; |
| |
| template <class StateName,class Param1> |
| struct SubState_ : euml_action<SubState_<StateName, Param1> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef StateName& type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef StateName& type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| StateName& operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| return (Param1()(evt,fsm,src,tgt)).template get_state<StateName&>(); |
| } |
| template <class Event,class FSM,class STATE> |
| StateName& operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| return (Param1()(evt,fsm,state)).template get_state<StateName&>(); |
| } |
| }; |
| template <class StateName> |
| struct SubState_ <StateName,void> |
| : euml_action<SubState_<StateName, void > > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef StateName& type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef StateName& type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| StateName& operator()(EVT const&,FSM& fsm,SourceState& ,TargetState& )const |
| { |
| return fsm.template get_state<StateName&>(); |
| } |
| template <class Event,class FSM,class STATE> |
| StateName& operator()(Event const& ,FSM& fsm,STATE& )const |
| { |
| return fsm.template get_state<StateName&>(); |
| } |
| }; |
| |
| struct SubState_Helper: proto::extends< proto::terminal<fsm_artefact_tag>::type, SubState_Helper, sm_domain> |
| { |
| SubState_Helper(){} |
| using proto::extends< proto::terminal<fsm_artefact_tag>::type, SubState_Helper, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef SubState_<Arg1,Arg2> type; |
| }; |
| }; |
| SubState_Helper const substate_; |
| |
| template <class Target,class Index> |
| struct GetAttribute_ : euml_action<GetAttribute_<Target, Index> > |
| { |
| using euml_action<GetAttribute_<Target,Index> >::operator=; |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef typename |
| ::boost::fusion::result_of::at_key< |
| typename get_attributes_type< |
| typename ::boost::remove_reference< |
| typename get_result_type2<Target,Event,FSM,STATE>::type>::type>::type, |
| Index >::type type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename |
| ::boost::fusion::result_of::at_key< |
| typename get_attributes_type< |
| typename ::boost::remove_reference< |
| typename get_result_type<Target,EVT,FSM,SourceState,TargetState>::type>::type>::type, |
| Index >::type type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename ::boost::enable_if< |
| typename ::boost::mpl::has_key< |
| typename Target::tag_type,action_tag>::type, |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| return (Target()(evt,fsm,src,tgt)).get_attribute(Index()); |
| } |
| template <class Event,class FSM,class STATE> |
| typename ::boost::enable_if< |
| typename ::boost::mpl::has_key< |
| typename Target::tag_type,state_action_tag>::type, |
| typename state_action_result<Event,FSM,STATE>::type >::type |
| operator()(Event const& evt,FSM& fsm,STATE& state )const |
| { |
| return (Target()(evt,fsm,state)).get_attribute(Index()); |
| } |
| }; |
| |
| struct GetAttribute_Helper: proto::extends< proto::terminal<fsm_artefact_tag>::type, GetAttribute_Helper, sm_domain> |
| { |
| GetAttribute_Helper(){} |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef GetAttribute_<Arg1,Arg2> type; |
| }; |
| }; |
| GetAttribute_Helper const attribute_; |
| |
| template <class Index> |
| struct Source_ : euml_action<Source_<Index> > |
| { |
| using euml_action<Source_<Index> >::operator=; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename |
| ::boost::fusion::result_of::at_key<typename SourceState::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& , FSM&,SourceState& src,TargetState& )const |
| { |
| return src.get_attribute(Index()); |
| } |
| }; |
| template <class Index> |
| struct Target_ : euml_action<Target_<Index> > |
| { |
| using euml_action<Target_<Index> >::operator=; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename |
| ::boost::fusion::result_of::at_key<typename TargetState::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& ,FSM& ,SourceState& ,TargetState& tgt)const |
| { |
| return tgt.get_attribute(Index()); |
| } |
| }; |
| template <class Index> |
| struct State_ : euml_action<State_<Index> > |
| { |
| using euml_action<State_<Index> >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef typename |
| ::boost::fusion::result_of::at_key<typename STATE::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const&,FSM& ,STATE& state ) |
| { |
| return state.get_attribute(Index()); |
| } |
| }; |
| template <class Index> |
| struct Event_ : euml_action<Event_<Index> > |
| { |
| using euml_action<Event_<Index> >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef typename ::boost::add_const< |
| typename ::boost::fusion::result_of::at_key<typename Event::attributes_type, |
| Index >::type>::type type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename ::boost::add_const< |
| typename ::boost::fusion::result_of::at_key<typename EVT::attributes_type, |
| Index >::type>::type type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const& evt,FSM& ,STATE& ) |
| { |
| return evt.get_attribute(Index()); |
| } |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const |
| { |
| return evt.get_attribute(Index()); |
| } |
| }; |
| template <class StateType,class Index> |
| struct State_Attribute_ : euml_action<State_Attribute_<StateType,Index> > |
| { |
| using euml_action<State_Attribute_<StateType,Index> >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef typename |
| ::boost::fusion::result_of::at_key<typename StateType::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const&,FSM& fsm,STATE& ) |
| { |
| return fsm.template get_state<StateType&>().get_attribute(Index()); |
| } |
| }; |
| |
| template <class Index> |
| struct Fsm_ : euml_action<Fsm_<Index> > |
| { |
| using euml_action<Fsm_<Index> >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef typename |
| ::boost::fusion::result_of::at_key<typename FSM::attributes_type, |
| Index >::type type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef typename |
| ::boost::fusion::result_of::at_key<typename FSM::attributes_type, |
| Index >::type type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class Event,class FSM,class STATE> |
| typename state_action_result<Event,FSM,STATE>::type |
| operator()(Event const&,FSM& fsm,STATE& ) |
| { |
| return fsm.get_attribute(Index()); |
| } |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type |
| operator()(EVT const& evt ,FSM& fsm,SourceState& ,TargetState&)const |
| { |
| return fsm.get_attribute(Index()); |
| } |
| }; |
| |
| struct True_ : euml::euml_action<True_> |
| { |
| using euml_action<True_>::operator=; |
| True_(){} |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef bool type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef bool type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| bool operator()(EVT const& evt,FSM&,SourceState& ,TargetState& ) |
| { |
| return true; |
| } |
| template <class Event,class FSM,class STATE> |
| bool operator()(Event const&,FSM&,STATE& ) |
| { |
| return true; |
| } |
| }; |
| True_ const true_; |
| |
| struct False_ : euml::euml_action<False_> |
| { |
| using euml_action<False_>::operator=; |
| False_(){} |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef bool type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef bool type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| bool operator()(EVT const& evt,FSM&,SourceState& ,TargetState& ) |
| { |
| return false; |
| } |
| template <class Event,class FSM,class STATE> |
| bool operator()(Event const&,FSM&,STATE& ) |
| { |
| return false; |
| } |
| }; |
| False_ const false_; |
| |
| template <int Val> |
| struct Int_ : euml_action<Int_<Val> > |
| { |
| using euml_action<Int_<Val> >::operator=; |
| typedef ::boost::mpl::int_<Val> value_type; |
| enum {value = Val}; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef int type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef int type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| int operator()(EVT const& , FSM& ,SourceState& ,TargetState& ) |
| { |
| return Val; |
| } |
| template <class Event,class FSM,class STATE> |
| int operator()(Event const& ,FSM& ,STATE& ) |
| { |
| return Val; |
| } |
| }; |
| |
| template <char Val> |
| struct Char_ : euml_action<Char_<Val> > |
| { |
| using euml_action<Char_<Val> >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef char type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef char type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| char operator()(EVT const& , FSM& ,SourceState& ,TargetState& ) |
| { |
| return Val; |
| } |
| template <class Event,class FSM,class STATE> |
| char operator()(Event const& ,FSM& ,STATE& ) |
| { |
| return Val; |
| } |
| }; |
| |
| template <size_t Val> |
| struct Size_t_ : euml_action<Size_t_<Val> > |
| { |
| using euml_action<Size_t_<Val> >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef size_t type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef size_t type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| size_t operator()(EVT const& , FSM& ,SourceState& ,TargetState& ) |
| { |
| return Val; |
| } |
| template <class Event,class FSM,class STATE> |
| size_t operator()(Event const& ,FSM& ,STATE& ) |
| { |
| return Val; |
| } |
| }; |
| |
| #if BOOST_VERSION >= 104000 |
| |
| template <class T> |
| struct String_ : euml_action<String_<T> > |
| { |
| using euml_action<String_<T> >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef char const* type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef char const* type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| char const* operator()(EVT const& , FSM& ,SourceState& ,TargetState& ) |
| { |
| return ::boost::mpl::c_str<T>::value; |
| } |
| template <class Event,class FSM,class STATE> |
| char const* operator()(Event const& ,FSM& ,STATE& ) |
| { |
| return ::boost::mpl::c_str<T>::value; |
| } |
| }; |
| #endif |
| |
| |
| template <class T> |
| struct Predicate_ : euml_action<Predicate_<T> > |
| { |
| using euml_action<Predicate_<T> >::operator=; |
| |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef T type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef T type; |
| }; |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| T operator()(EVT const& , FSM& ,SourceState& ,TargetState& ) |
| { |
| return T(); |
| } |
| template <class Event,class FSM,class STATE> |
| T operator()(Event const& ,FSM& ,STATE& ) |
| { |
| return T(); |
| } |
| }; |
| |
| template <class ToProcessEvt,class Param1, class Param2, class Param3, class Param4> |
| struct Process_ : euml_action<Process_<ToProcessEvt, Param1, Param2, Param3, Param4> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| (Param1()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| (Param2()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| (Param3()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| (Param4()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| (Param1()(evt,fsm,state)).process_event(ToProcessEvt()); |
| (Param2()(evt,fsm,state)).process_event(ToProcessEvt()); |
| (Param3()(evt,fsm,state)).process_event(ToProcessEvt()); |
| (Param4()(evt,fsm,state)).process_event(ToProcessEvt()); |
| } |
| }; |
| template <class ToProcessEvt> |
| struct Process_ <ToProcessEvt,void,void,void,void> |
| : euml_action<Process_<ToProcessEvt, void, void, void, void > > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const&,FSM& fsm,SourceState& ,TargetState& )const |
| { |
| fsm.process_event(ToProcessEvt()); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& ,FSM& fsm,STATE& )const |
| { |
| fsm.process_event(ToProcessEvt()); |
| } |
| }; |
| |
| template <class ToProcessEvt,class Param1> |
| struct Process_ <ToProcessEvt,Param1,void,void,void> |
| : euml_action<Process_<ToProcessEvt, Param1, void, void, void> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| (Param1()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| (Param1()(evt,fsm,state)).process_event(ToProcessEvt()); |
| } |
| }; |
| |
| template <class ToProcessEvt,class Param1, class Param2> |
| struct Process_ <ToProcessEvt,Param1,Param2,void,void> |
| : euml_action<Process_<ToProcessEvt, Param1, Param2, void, void> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| (Param1()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| (Param2()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| (Param1()(evt,fsm,state)).process_event(ToProcessEvt()); |
| (Param2()(evt,fsm,state)).process_event(ToProcessEvt()); |
| } |
| }; |
| |
| template <class ToProcessEvt,class Param1, class Param2, class Param3> |
| struct Process_ <ToProcessEvt,Param1,Param2,Param3,void> |
| : euml_action<Process_<ToProcessEvt, Param1, Param2, Param3, void> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| (Param1()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| (Param2()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| (Param3()(evt,fsm,src,tgt)).process_event(ToProcessEvt()); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| (Param1()(evt,fsm,state)).process_event(ToProcessEvt()); |
| (Param2()(evt,fsm,state)).process_event(ToProcessEvt()); |
| (Param3()(evt,fsm,state)).process_event(ToProcessEvt()); |
| } |
| }; |
| struct process_tag {}; |
| struct Process_Helper: proto::extends< proto::terminal<process_tag>::type, Process_Helper, sm_domain> |
| { |
| Process_Helper(){} |
| using proto::extends< proto::terminal<process_tag>::type, Process_Helper, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef Process_<Arg1,Arg2,Arg3,Arg4,Arg5> type; |
| }; |
| }; |
| Process_Helper const process_; |
| |
| template <class ToProcessEvt,class Value,class Param1, class Param2, class Param3> |
| struct Process2_ : euml_action<Process2_<ToProcessEvt,Value, Param1, Param2, Param3> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| (Param1()(evt,fsm,src,tgt)).process_event(ToProcessEvt(Value()(evt,fsm,src,tgt))); |
| (Param2()(evt,fsm,src,tgt)).process_event(ToProcessEvt(Value()(evt,fsm,src,tgt))); |
| (Param3()(evt,fsm,src,tgt)).process_event(ToProcessEvt(Value()(evt,fsm,src,tgt))); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| (Param1()(evt,fsm,state)).process_event(ToProcessEvt(Value()(evt,fsm,state))); |
| (Param2()(evt,fsm,state)).process_event(ToProcessEvt(Value()(evt,fsm,state))); |
| (Param3()(evt,fsm,state)).process_event(ToProcessEvt(Value()(evt,fsm,state))); |
| } |
| }; |
| |
| template <class ToProcessEvt,class Value> |
| struct Process2_ <ToProcessEvt,Value,void,void,void> |
| : euml_action<Process2_<ToProcessEvt,Value, void, void, void > > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| fsm.process_event(ToProcessEvt(Value()(evt,fsm,src,tgt))); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| fsm.process_event(ToProcessEvt(Value()(evt,fsm,state))); |
| } |
| }; |
| |
| template <class ToProcessEvt,class Value,class Param1> |
| struct Process2_ <ToProcessEvt,Value,Param1,void,void> |
| : euml_action<Process2_<ToProcessEvt,Value, Param1, void, void> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| (Param1()(evt,fsm,src,tgt)).process_event(ToProcessEvt(Value()(evt,fsm,src,tgt))); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| (Param1()(evt,fsm,state)).process_event(ToProcessEvt(Value()(evt,fsm,state))); |
| } |
| }; |
| |
| template <class ToProcessEvt,class Value,class Param1, class Param2> |
| struct Process2_ <ToProcessEvt,Value,Param1,Param2,void> |
| : euml_action<Process2_<ToProcessEvt,Value, Param1, Param2, void> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef void type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef void type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| (Param1()(evt,fsm,src,tgt)).process_event(ToProcessEvt(Value()(evt,fsm,src,tgt))); |
| (Param2()(evt,fsm,src,tgt)).process_event(ToProcessEvt(Value()(evt,fsm,src,tgt))); |
| } |
| template <class Event,class FSM,class STATE> |
| void operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| (Param1()(evt,fsm,state)).process_event(ToProcessEvt(Value()(evt,fsm,state))); |
| (Param2()(evt,fsm,state)).process_event(ToProcessEvt(Value()(evt,fsm,state))); |
| } |
| }; |
| |
| struct process2_tag {}; |
| struct Process2_Helper : proto::extends< proto::terminal<process2_tag>::type, Process2_Helper, sm_domain> |
| { |
| Process2_Helper(){} |
| using proto::extends< proto::terminal<process2_tag>::type, Process2_Helper, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef Process2_<Arg1,Arg2,Arg3,Arg4,Arg5> type; |
| }; |
| }; |
| Process2_Helper const process2_; |
| |
| template <class Flag,class Param1=void, class Enable=void > |
| struct Get_Flag_ : euml_action<Get_Flag_<Flag,Param1,Enable> > {}; |
| |
| template <class Flag,class Param1> |
| struct Get_Flag_ <Flag,Param1 |
| , typename ::boost::enable_if<typename ::boost::is_same<Param1,void>::type >::type> |
| : euml_action<Get_Flag_<Flag, Param1> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef bool type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef bool type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| bool operator()(EVT const&,FSM& fsm,SourceState& ,TargetState& )const |
| { |
| return fsm.template is_flag_active<Flag>(); |
| } |
| template <class Event,class FSM,class STATE> |
| bool operator()(Event const& ,FSM& fsm,STATE& )const |
| { |
| return fsm.template is_flag_active<Flag>(); |
| } |
| }; |
| |
| template <class Flag,class Param1> |
| struct Get_Flag_ <Flag,Param1 |
| , typename ::boost::disable_if< |
| typename ::boost::is_same<Param1,void>::type |
| >::type> |
| : euml_action<Get_Flag_<Flag, Param1> > |
| { |
| template <class Event,class FSM,class STATE > |
| struct state_action_result |
| { |
| typedef bool type; |
| }; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| struct transition_action_result |
| { |
| typedef bool type; |
| }; |
| |
| typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type; |
| |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| bool operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)const |
| { |
| return (Param1()(evt,fsm,src,tgt)).template is_flag_active<Flag>(); |
| } |
| template <class Event,class FSM,class STATE> |
| bool operator()(Event const& evt,FSM& fsm,STATE& state)const |
| { |
| return (Param1()(evt,fsm,state)).template is_flag_active<Flag>(); |
| } |
| }; |
| |
| struct Get_Flag_Helper: proto::extends< proto::terminal<fsm_artefact_tag>::type, Get_Flag_Helper, sm_domain> |
| { |
| Get_Flag_Helper(){} |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef Get_Flag_<Arg1,Arg2> type; |
| }; |
| }; |
| Get_Flag_Helper const is_flag_; |
| |
| // deferring an event |
| struct DeferEvent_ : euml_action< DeferEvent_ > |
| { |
| typedef ::boost::mpl::set<action_tag> tag_type; |
| template <class EVT,class FSM,class SourceState,class TargetState> |
| void operator()(EVT const& evt,FSM& fsm,SourceState& ,TargetState& ) const |
| { |
| fsm.defer_event(evt); |
| } |
| }; |
| struct Defer_Helper : proto::extends< proto::terminal<fsm_artefact_tag>::type, Defer_Helper, sm_domain> |
| { |
| Defer_Helper(){} |
| using proto::extends< proto::terminal<fsm_artefact_tag>::type, Defer_Helper, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef DeferEvent_ type; |
| }; |
| }; |
| Defer_Helper const defer_; |
| |
| struct explicit_tag {}; |
| struct Explicit_Helper : proto::extends< proto::terminal<explicit_tag>::type, Explicit_Helper, sm_domain> |
| { |
| Explicit_Helper(){} |
| using proto::extends< proto::terminal<explicit_tag>::type, Explicit_Helper, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef typename Arg1::template direct<Arg2> type; |
| }; |
| }; |
| Explicit_Helper const explicit_; |
| |
| struct entry_pt_tag {}; |
| struct Entry_Pt_Helper : proto::extends< proto::terminal<entry_pt_tag>::type, Entry_Pt_Helper, sm_domain> |
| { |
| Entry_Pt_Helper(){} |
| using proto::extends< proto::terminal<entry_pt_tag>::type, Entry_Pt_Helper, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef typename Arg1::template entry_pt<Arg2> type; |
| }; |
| }; |
| Entry_Pt_Helper const entry_pt_; |
| |
| struct exit_pt_tag {}; |
| struct Exit_Pt_Helper : proto::extends< proto::terminal<exit_pt_tag>::type, Exit_Pt_Helper, sm_domain> |
| { |
| Exit_Pt_Helper(){} |
| using proto::extends< proto::terminal<exit_pt_tag>::type, Exit_Pt_Helper, sm_domain>::operator=; |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 |
| #ifdef BOOST_MSVC |
| ,class Arg6 |
| #endif |
| > |
| struct In |
| { |
| typedef typename Arg1::template exit_pt<Arg2> type; |
| }; |
| }; |
| Exit_Pt_Helper const exit_pt_; |
| |
| #ifdef BOOST_MSVC |
| #define BOOST_MSM_EUML_FUNCTION(functor,function,function_name,result_trans,result_state) \ |
| template <class Param1=void , class Param2=void , class Param3=void , class Param4=void, \ |
| class Param5=void,class Param6=void,class Enable=void > \ |
| struct functor : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6,Enable> > {}; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::enable_if<typename ::boost::is_same<Param1,void>::type>::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type \ |
| operator()(EVT const& , FSM& ,SourceState& ,TargetState& )const { \ |
| return function ();} \ |
| template <class Event,class FSM,class STATE> \ |
| typename state_action_result<Event,FSM,STATE>::type \ |
| operator()(Event const& ,FSM& ,STATE& )const { \ |
| return function ();} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param1,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param2,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param2,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param3,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param3,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param4,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param4,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param5,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param5,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param6,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt),Param5()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state),Param5()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::is_same<Param6,void>::type>::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt),Param5()(evt,fsm,src,tgt),Param6()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state),Param5()(evt,fsm,state),Param6()(evt,fsm,state));} }; \ |
| struct function_name ## tag{}; \ |
| struct functor ## Helper : proto::extends< proto::terminal< function_name ## tag >::type, \ |
| functor ## Helper , sm_domain> { functor ## Helper(){} \ |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5,class Arg6> \ |
| struct In {typedef functor <Arg1,Arg2,Arg3,Arg4,Arg5,Arg6> type;}; }; \ |
| functor ## Helper const function_name ; |
| |
| #define BOOST_MSM_EUML_METHOD(functor,function,function_name,result_trans,result_state) \ |
| template <class Param1=void , class Param2=void , class Param3=void , class Param4=void, \ |
| class Param5=void,class Param6=void,class Enable=void > \ |
| struct functor : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6,Enable> > {}; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5, class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::enable_if<typename ::boost::is_same<Param2,void>::type>::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function();} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function();} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param2,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param3,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param3,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param4,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state),Param3()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param4,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param5,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param5,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param6,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt),Param5()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state),Param5()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5,class Param6> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5,Param6, \ |
| typename ::boost::disable_if<typename ::boost::is_same<Param6,void>::type>::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Param6> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt),Param5()(evt,fsm,src,tgt),Param6()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state),Param5()(evt,fsm,state),Param6()(evt,fsm,state));} }; \ |
| struct function_name ## tag{}; \ |
| struct functor ## Helper : proto::extends< proto::terminal< function_name ## tag >::type, \ |
| functor ## Helper , sm_domain> { functor ## Helper(){} \ |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5,class Arg6> \ |
| struct In {typedef functor <Arg1,Arg2,Arg3,Arg4,Arg5,Arg6> type;}; }; \ |
| functor ## Helper const function_name ; |
| |
| #else |
| |
| #define BOOST_MSM_EUML_FUNCTION(functor,function,function_name,result_trans,result_state) \ |
| template <class Param1=void , class Param2=void , class Param3=void , class Param4=void, \ |
| class Param5=void,class Enable=void > \ |
| struct functor : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Enable> > {}; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param1,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param2,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param2,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param3,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param3,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param4,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param4,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param5,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::is_same<Param5,void>::type>::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return function (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt),Param5()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return function (Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state),Param5()(evt,fsm,state));} }; \ |
| struct function_name ## tag{}; \ |
| struct functor ## Helper : proto::extends< proto::terminal< function_name ## tag >::type, \ |
| functor ## Helper , sm_domain> { functor ## Helper(){} \ |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5> \ |
| struct In {typedef functor <Arg1,Arg2,Arg3,Arg4,Arg5> type;}; }; \ |
| functor ## Helper const function_name ; |
| |
| #define BOOST_MSM_EUML_METHOD(functor,function,function_name,result_trans,result_state) \ |
| template <class Param1=void , class Param2=void , class Param3=void , class Param4=void, \ |
| class Param5=void,class Enable=void > \ |
| struct functor : euml_action<functor<Param1,Param2,Param3,Param4,Param5,Enable> > {}; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::enable_if<typename ::boost::is_same<Param2,void>::type>::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function();} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function();} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param2,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param3,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param3,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param4,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state),Param3()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::mpl::or_< \ |
| typename ::boost::is_same<Param4,void>::type,typename ::boost::mpl::not_< \ |
| typename ::boost::is_same<Param5,void>::type>::type>::type >::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state));} }; \ |
| template <class Param1, class Param2, class Param3, class Param4, class Param5> \ |
| struct functor<Param1,Param2,Param3,Param4,Param5, \ |
| typename ::boost::disable_if<typename ::boost::is_same<Param5,void>::type>::type> \ |
| : euml_action<functor<Param1,Param2,Param3,Param4,Param5> > { \ |
| template <class Event,class FSM,class STATE > struct state_action_result { \ |
| typedef result_state type;} ; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| struct transition_action_result { typedef result_trans type;}; \ |
| typedef ::boost::mpl::set<boost::msm::front::state_action_tag,boost::msm::front::action_tag> tag_type; \ |
| template <class EVT,class FSM,class SourceState,class TargetState> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::action_tag>::type, \ |
| typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type \ |
| operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { \ |
| return (Param1()(evt,fsm,src,tgt)).function(Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt) \ |
| ,Param4()(evt,fsm,src,tgt),Param5()(evt,fsm,src,tgt));} \ |
| template <class Event,class FSM,class STATE> \ |
| typename ::boost::enable_if<typename ::boost::mpl::has_key< \ |
| typename Param1::tag_type,boost::msm::front::state_action_tag>::type, \ |
| typename state_action_result<Event,FSM,STATE>::type >::type \ |
| operator()(Event const& evt,FSM& fsm,STATE& state )const { \ |
| return (Param1()(evt,fsm,state)).function(Param2()(evt,fsm,state),Param3()(evt,fsm,state) \ |
| ,Param4()(evt,fsm,state),Param5()(evt,fsm,state));} }; \ |
| struct function_name ## tag{}; \ |
| struct functor ## Helper : proto::extends< proto::terminal< function_name ## tag >::type, \ |
| functor ## Helper , sm_domain> { functor ## Helper(){} \ |
| template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5> \ |
| struct In {typedef functor <Arg1,Arg2,Arg3,Arg4,Arg5> type;}; }; \ |
| functor ## Helper const function_name ; |
| |
| #endif |
| |
| #define RESULT_TYPE2_PARAM1 typename get_result_type2<Param1,Event,FSM,STATE>::type |
| #define RESULT_TYPE_PARAM1 typename get_result_type<Param1,EVT,FSM,SourceState,TargetState>::type |
| #define RESULT_TYPE2_PARAM2 typename get_result_type2<Param2,Event,FSM,STATE>::type |
| #define RESULT_TYPE_PARAM2 typename get_result_type<Param2,EVT,FSM,SourceState,TargetState>::type |
| #define RESULT_TYPE2_PARAM3 typename get_result_type2<Param3,Event,FSM,STATE>::type |
| #define RESULT_TYPE_PARAM3 typename get_result_type<Param3,EVT,FSM,SourceState,TargetState>::type |
| #define RESULT_TYPE2_PARAM4 typename get_result_type2<Param4,Event,FSM,STATE>::type |
| #define RESULT_TYPE_PARAM4 typename get_result_type<Param4,EVT,FSM,SourceState,TargetState>::type |
| #define RESULT_TYPE2_PARAM5 typename get_result_type2<Param5,Event,FSM,STATE>::type |
| #define RESULT_TYPE_PARAM5 typename get_result_type<Param5,EVT,FSM,SourceState,TargetState>::type |
| #define RESULT_TYPE2_PARAM6 typename get_result_type2<Param6,Event,FSM,STATE>::type |
| #define RESULT_TYPE_PARAM6 typename get_result_type<Param6,EVT,FSM,SourceState,TargetState>::type |
| |
| |
| #define RESULT_TYPE2_DIFF_TYPE_ITER_TRAITS_PARAM1 typename std::iterator_traits<typename get_result_type2<Param1,Event,FSM,STATE>::type>::difference_type |
| #define RESULT_TYPE_DIFF_TYPE_ITER_TRAITS_PARAM1 typename std::iterator_traits<typename get_result_type<Param1,EVT,FSM,SourceState,TargetState>::type>::difference_type |
| |
| #define RESULT_TYPE2_REMOVE_REF_PARAM1 typename ::boost::remove_reference<typename get_result_type2<Param1,Event,FSM,STATE>::type>::type |
| #define RESULT_TYPE_REMOVE_REF_PARAM1 typename ::boost::remove_reference<typename get_result_type<Param1,EVT,FSM,SourceState,TargetState>::type>::type |
| |
| #define RESULT_TYPE2_PAIR_REMOVE_REF_PARAM1 std::pair<RESULT_TYPE2_REMOVE_REF_PARAM1,RESULT_TYPE2_REMOVE_REF_PARAM1> |
| #define RESULT_TYPE_PAIR_REMOVE_REF_PARAM1 std::pair<RESULT_TYPE_REMOVE_REF_PARAM1,RESULT_TYPE_REMOVE_REF_PARAM1> |
| |
| #define RESULT_TYPE2_GET_REF_REMOVE_REF_PARAM1 typename get_reference<typename ::boost::remove_reference<typename get_result_type2<Param1,Event,FSM,STATE>::type>::type>::type |
| #define RESULT_TYPE_GET_REF_REMOVE_REF_PARAM1 typename get_reference<typename ::boost::remove_reference<typename get_result_type<Param1,EVT,FSM,SourceState,TargetState>::type>::type>::type |
| |
| #define RESULT_TYPE2_GET_ITERATOR_REMOVE_REF_PARAM1 typename get_iterator<typename ::boost::remove_reference<typename get_result_type2<Param1,Event,FSM,STATE>::type>::type>::type |
| #define RESULT_TYPE_GET_ITERATOR_REMOVE_REF_PARAM1 typename get_iterator<typename ::boost::remove_reference<typename get_result_type<Param1,EVT,FSM,SourceState,TargetState>::type>::type>::type |
| |
| #define RESULT_TYPE2_GET_REV_ITERATOR_REMOVE_REF_PARAM1 typename get_reverse_iterator<typename ::boost::remove_reference<typename get_result_type2<Param1,Event,FSM,STATE>::type>::type>::type |
| #define RESULT_TYPE_GET_REV_ITERATOR_REMOVE_REF_PARAM1 typename get_reverse_iterator<typename ::boost::remove_reference<typename get_result_type<Param1,EVT,FSM,SourceState,TargetState>::type>::type>::type |
| |
| #define RESULT_TYPE2_GET_SIZE_TYPE_REMOVE_REF_PARAM1 typename get_size_type<typename ::boost::remove_reference<typename get_result_type2<Param1,Event,FSM,STATE>::type>::type>::type |
| #define RESULT_TYPE_GET_SIZE_TYPE_REMOVE_REF_PARAM1 typename get_size_type<typename ::boost::remove_reference<typename get_result_type<Param1,EVT,FSM,SourceState,TargetState>::type>::type>::type |
| |
| #define BOOST_MSM_EUML_ACTION(instance_name) \ |
| struct instance_name ## _impl; \ |
| struct instance_name ## _helper : msm::front::euml::euml_action<instance_name ## _impl> \ |
| { \ |
| instance_name ## _helper(){} \ |
| typedef instance_name ## _impl action_name; \ |
| }; \ |
| instance_name ## _helper instance_name; \ |
| struct instance_name ## _impl : instance_name ## _helper |
| |
| |
| #define BOOST_MSM_EUML_EVENT(instance_name) \ |
| struct instance_name ## _helper : msm::front::euml::euml_event<instance_name ## _helper>{ \ |
| instance_name ## _helper(){} \ |
| instance_name ## _helper const& operator()(){return *this;} }; \ |
| instance_name ## _helper instance_name; |
| |
| #define MSM_EUML_CONCAT(param1,param2) param1 |
| #define MSM_EUML_EVENT_INSTANCE_HELPER_EXECUTE1(z, n, unused) ARG ## n arg ## n |
| #define MSM_EUML_EVENT_INSTANCE_HELPER_EXECUTE2(z, n, unused) arg ## n |
| #define MSM_EUML_EVENT_INSTANCE_HELPER_ATTRIBUTE_MAP_ENTRY(z, n, unused) \ |
| typename boost::fusion::result_of::first< \ |
| typename ::boost::remove_reference< \ |
| typename boost::fusion::result_of::at_c<T, BOOST_PP_CAT( , n)>::type>::type>::type \ |
| |
| #define MSM_EUML_EVENT_HELPER_GET_ATTRIBUTE(z, n, unused) \ |
| get_attribute( \ |
| typename boost::fusion::result_of::first< \ |
| typename ::boost::remove_reference< \ |
| typename boost::fusion::result_of::at_c<T, n>::type>::type>::type())=arg ## n; |
| |
| #define MSM_EUML_EVENT_HELPER_CONSTRUCTORS(z, n, mytuple) \ |
| template <BOOST_PP_ENUM_PARAMS(n, class ARG)> \ |
| BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, mytuple) , _helper)(BOOST_PP_ENUM(n, MSM_EUML_EVENT_INSTANCE_HELPER_EXECUTE1, ~ )): \ |
| BOOST_PP_TUPLE_ELEM(2, 1, mytuple)(){ \ |
| init(BOOST_PP_ENUM(n, MSM_EUML_EVENT_INSTANCE_HELPER_EXECUTE2, ~ ),attribute_vec());} |
| |
| #define MSM_EUML_EVENT_INSTANCE_HELPER_ATTRIBUTE_MAP(z, n, unused) \ |
| template <BOOST_PP_ENUM_PARAMS(n, class ARG),class T> \ |
| void init(BOOST_PP_ENUM(n, MSM_EUML_EVENT_INSTANCE_HELPER_EXECUTE1, ~ ), \ |
| T,typename ::boost::enable_if< typename boost::mpl::eval_if< typename ::boost::fusion::traits::is_sequence<T>::type,size_helper<T,n>,::boost::mpl::false_>::type,void >::type* dummyval=0) \ |
| { \ |
| BOOST_PP_REPEAT_FROM_TO(0,n , \ |
| MSM_EUML_EVENT_HELPER_GET_ATTRIBUTE, ~) \ |
| } |
| |
| #define MSM_EUML_EVENT_INSTANCE_HELPER_OPERATOR_IMPL(z, n, instance) \ |
| template <BOOST_PP_ENUM_PARAMS(n, class ARG)> \ |
| BOOST_PP_CAT(instance,_helper) operator() \ |
| (BOOST_PP_ENUM(n, MSM_EUML_EVENT_INSTANCE_HELPER_EXECUTE1, ~ ))const{ \ |
| return BOOST_PP_CAT(instance,_helper) (BOOST_PP_ENUM(n, MSM_EUML_EVENT_INSTANCE_HELPER_EXECUTE2, ~ ));} |
| |
| #define BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(instance_name, attributes_name) \ |
| struct instance_name ## _helper : \ |
| msm::front::euml::euml_event<instance_name ## _helper> , public attributes_name \ |
| { \ |
| template <class T,int checked_size> struct size_helper \ |
| { \ |
| typedef typename ::boost::mpl::less_equal< \ |
| typename ::boost::fusion::result_of::size<T>::type, \ |
| ::boost::mpl::int_<checked_size> >::type type; \ |
| }; \ |
| BOOST_PP_CAT(instance_name,_helper()) : attributes_name(){} \ |
| typedef attributes_name::attributes_type attribute_map; \ |
| typedef ::boost::fusion::result_of::as_vector<attribute_map>::type attribute_vec; \ |
| BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_ADD(FUSION_MAX_MAP_SIZE ,1), \ |
| MSM_EUML_EVENT_HELPER_CONSTRUCTORS, (instance_name,attributes_name)) \ |
| BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_ADD(FUSION_MAX_MAP_SIZE ,1), \ |
| MSM_EUML_EVENT_INSTANCE_HELPER_ATTRIBUTE_MAP, ~) \ |
| BOOST_PP_CAT(instance_name,_helper) operator()(){ \ |
| return BOOST_PP_CAT(instance_name,_helper)();} \ |
| BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_ADD(FUSION_MAX_MAP_SIZE ,1), \ |
| MSM_EUML_EVENT_INSTANCE_HELPER_OPERATOR_IMPL, instance_name) \ |
| }; \ |
| instance_name ## _helper const instance_name; |
| |
| #define BOOST_MSM_EUML_EVENT_NAME(instance_name) instance_name ## _helper |
| |
| #define BOOST_MSM_EUML_FLAG_NAME(instance_name) instance_name ## _helper |
| |
| #define BOOST_MSM_EUML_FLAG(instance_name) \ |
| struct instance_name ## _helper : msm::front::euml::euml_flag<instance_name ## _helper>{}; \ |
| instance_name ## _helper instance_name; |
| |
| #define BOOST_MSM_EUML_STATE_NAME(instance_name) instance_name ## _helper |
| |
| #define BOOST_MSM_EUML_BUILD_STT_HELPER build_stt( |
| #define BOOST_MSM_EUML_BUILD_INTERNAL_STT_HELPER build_internal_stt( |
| #define BOOST_MSM_EUML_BUILD_STT_HELPER2(expr) expr) |
| #define BOOST_MSM_EUML_ENTRY_STATE_HELPER(expr) ,expr |
| |
| |
| #define BOOST_MSM_EUML_ATTRIBUTES(expr,instance_name) \ |
| typedef BOOST_TYPEOF(build_attributes expr) instance_name; |
| |
| // following macros declare a state type but do not create an instance |
| #define BOOST_MSM_EUML_DECLARE_STATE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_state<instance_name ## tag> expr) instance_name; |
| |
| #define BOOST_MSM_EUML_DECLARE_INTERRUPT_STATE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_interrupt_state<instance_name ## tag> expr) instance_name; |
| |
| #define BOOST_MSM_EUML_DECLARE_TERMINATE_STATE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_terminate_state<instance_name ## tag> expr) instance_name; |
| |
| #define BOOST_MSM_EUML_DECLARE_EXPLICIT_ENTRY_STATE(region,expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_explicit_entry_state<instance_name ## tag BOOST_MSM_EUML_ENTRY_STATE_HELPER(region) > expr) instance_name; |
| |
| #define BOOST_MSM_EUML_DECLARE_ENTRY_STATE(region,expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_entry_state<instance_name ## tag BOOST_MSM_EUML_ENTRY_STATE_HELPER(region) > expr) instance_name; |
| |
| #define BOOST_MSM_EUML_DECLARE_EXIT_STATE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_exit_state<instance_name ## tag> expr) instance_name; |
| |
| #define BOOST_MSM_EUML_DECLARE_STATE_MACHINE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_sm<instance_name ## tag> expr) instance_name; |
| |
| #define BOOST_MSM_EUML_DECLARE_TRANSITION_TABLE(expr,instance_name) \ |
| typedef BOOST_TYPEOF(BOOST_MSM_EUML_BUILD_STT_HELPER BOOST_MSM_EUML_BUILD_STT_HELPER2(expr)) instance_name; |
| |
| #define BOOST_MSM_EUML_DECLARE_INTERNAL_TRANSITION_TABLE(expr) \ |
| typedef BOOST_TYPEOF( \ |
| BOOST_MSM_EUML_BUILD_INTERNAL_STT_HELPER BOOST_MSM_EUML_BUILD_STT_HELPER2(expr)) internal_transition_table; |
| |
| // following macros declare a state type and create an instance |
| #define BOOST_MSM_EUML_STATE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_state<instance_name ## tag> expr) instance_name ## _helper; \ |
| instance_name ## _helper const instance_name; |
| |
| #define BOOST_MSM_EUML_INTERRUPT_STATE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_interrupt_state<instance_name ## tag> expr) instance_name ## _helper; \ |
| instance_name ## _helper const instance_name; |
| |
| #define BOOST_MSM_EUML_TERMINATE_STATE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_terminate_state<instance_name ## tag> expr) instance_name ## _helper; \ |
| instance_name ## _helper const instance_name; |
| |
| #define BOOST_MSM_EUML_EXPLICIT_ENTRY_STATE(region,expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_explicit_entry_state<instance_name ## tag BOOST_MSM_EUML_ENTRY_STATE_HELPER(region) > expr) instance_name ## _helper; \ |
| instance_name ## _helper const instance_name; |
| |
| #define BOOST_MSM_EUML_ENTRY_STATE(region,expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_entry_state<instance_name ## tag BOOST_MSM_EUML_ENTRY_STATE_HELPER(region) > expr) instance_name ## _helper; \ |
| instance_name ## _helper const instance_name; |
| |
| #define BOOST_MSM_EUML_EXIT_STATE(expr,instance_name) \ |
| struct instance_name ## tag{}; \ |
| typedef BOOST_TYPEOF(build_exit_state<instance_name ## tag> expr) instance_name ## _helper; \ |
| instance_name ## _helper const instance_name; |
| |
| |
| #ifndef BOOST_MSVC |
| |
| #define BOOST_MSM_EUML_TRANSITION_TABLE(expr,instance_name) \ |
| typedef BOOST_TYPEOF(BOOST_MSM_EUML_BUILD_STT_HELPER BOOST_MSM_EUML_BUILD_STT_HELPER2(expr)) instance_name ## _def; \ |
| struct instance_name ## _helper : public instance_name ## _def{instance_name ## _helper(){}}; \ |
| instance_name ## _helper const instance_name; |
| |
| #define BOOST_MSM_EUML_INTERNAL_TRANSITION_TABLE(expr,instance_name) \ |
| typedef BOOST_TYPEOF(BOOST_MSM_EUML_BUILD_INTERNAL_STT_HELPER BOOST_MSM_EUML_BUILD_STT_HELPER2(expr)) instance_name ## _def; \ |
| struct instance_name ## _helper : public instance_name ## _def{instance_name ## _helper(){}}; \ |
| instance_name ## _helper const instance_name; |
| |
| #else |
| |
| #define BOOST_MSM_EUML_TRANSITION_TABLE(expr,instance_name) \ |
| struct instance_name ## _helper : \ |
| public BOOST_TYPEOF(BOOST_MSM_EUML_BUILD_STT_HELPER BOOST_MSM_EUML_BUILD_STT_HELPER2(expr)) \ |
| {instance_name ## _helper(){}} ; \ |
| instance_name ## _helper const instance_name; |
| |
| #define BOOST_MSM_EUML_INTERNAL_TRANSITION_TABLE(expr,instance_name) \ |
| struct instance_name ## _helper : \ |
| public BOOST_TYPEOF(BOOST_MSM_EUML_BUILD_INTERNAL_STT_HELPER BOOST_MSM_EUML_BUILD_STT_HELPER2(expr)) \ |
| {instance_name ## _helper(){}} ; \ |
| instance_name ## _helper const instance_name; |
| |
| #endif |
| |
| }}}} // boost::msm::front::euml |
| |
| #endif // BOOST_MSM_FRONT_EUML_COMMON_H |