blob: 525a2400eccaabe674581876b32e0124919a9fcf [file] [log] [blame]
// 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& ,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