FM / euml

/usr/include/boost/msm/front/euml

Name	Size	Mode	Actions
algorithm.hpp	748	0644	edit dl rm
common.hpp	140806	0644	edit dl rm
container.hpp	155786	0644	edit dl rm
euml.hpp	928	0644	edit dl rm
euml_typeof.hpp	7411	0644	edit dl rm
guard_grammar.hpp	13201	0644	edit dl rm
iteration.hpp	984	0644	edit dl rm
operator.hpp	57632	0644	edit dl rm
phoenix_placeholders.hpp	1198	0644	edit dl rm
querying.hpp	2940	0644	edit dl rm
state_grammar.hpp	70475	0644	edit dl rm
stl.hpp	679	0644	edit dl rm
stt_grammar.hpp	9269	0644	edit dl rm
transformation.hpp	15441	0644	edit dl rm

Edit: /usr/include/boost/msm/front/euml/operator.hpp (57632B)

#ifndef BOOST_MSM_FRONT_EUML_OPERATOR_H
#define BOOST_MSM_FRONT_EUML_OPERATOR_H

#include <iterator>
#include <boost/msm/front/euml/common.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/has_key.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/set.hpp>
#include <boost/type_traits.hpp>

BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
BOOST_MPL_HAS_XXX_TRAIT_DEF(key_type)

namespace boost { namespace msm { namespace front { namespace euml
{

template <class T1,class T2>
struct Or_ : euml_action<Or_<T1,T2> >
{
    template <class EVT,class FSM,class SourceState,class TargetState>
    bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
    {
        return (T1()(evt,fsm,src,tgt) || T2()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state)
    {
        return (T1()(evt,fsm,state) || T2()(evt,fsm,state));
    }
};
template <class T1,class T2>
struct And_ : euml_action<And_<T1,T2> >
{
    template <class EVT,class FSM,class SourceState,class TargetState>
    bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
    {
        return (T1()(evt,fsm,src,tgt) && T2()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state)
    {
        return (T1()(evt,fsm,state) && T2()(evt,fsm,state));
    }
};
template <class T1>
struct Not_ : euml_action<Not_<T1> >
{
    template <class EVT,class FSM,class SourceState,class TargetState>
    bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)
    {
        return !(T1()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state)
    {
        return !(T1()(evt,fsm,state));
    }
};

template <class Condition,class Action1,class Action2, class Enable=void >                                             
struct If_Else_ : euml_action<If_Else_<Condition,Action1,Action2,Enable> > {};

template <class Condition,class Action1,class Action2>
struct If_Else_<Condition,Action1,Action2
    , typename ::boost::enable_if<typename has_tag_type<Action1>::type >::type>
    : euml_action<If_Else_<Condition,Action1,Action2> >
{
    template <class Event,class FSM,class STATE >
    struct state_action_result 
    {
        typedef typename get_result_type2<Action1,Event,FSM,STATE>::type type;
    };
    template <class EVT,class FSM,class SourceState,class TargetState>
    struct transition_action_result 
    {
        typedef typename get_result_type<Action1,EVT,FSM,SourceState,TargetState>::type type;
    };
    typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;

template <class EVT,class FSM,class SourceState,class TargetState>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename Action1::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
    {
        if (Condition()(evt,fsm,src,tgt))
        {
            return Action1()(evt,fsm,src,tgt);
        }
        return Action2()(evt,fsm,src,tgt);
    }
    template <class Event,class FSM,class STATE>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename Action1::tag_type,state_action_tag>::type,
            typename state_action_result<Event,FSM,STATE>::type >::type 
     operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        if (Condition()(evt,fsm,state))
        {
            return Action1()(evt,fsm,state);
        }
        return Action2()(evt,fsm,state);
    }
};

template <class Condition,class Action1,class Action2>
struct If_Else_<Condition,Action1,Action2
    , typename ::boost::disable_if<typename has_tag_type<Action1>::type >::type>
    : euml_action<If_Else_<Condition,Action1,Action2> >
{
    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;

struct if_tag 
{
};
struct If : proto::extends<proto::terminal<if_tag>::type, If, boost::msm::sm_domain>
{
    If(){}
    using proto::extends< proto::terminal<if_tag>::type, If, boost::msm::sm_domain>::operator=;
    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
#ifdef BOOST_MSVC 
 ,class Arg6 
#endif
>
    struct In
    {
        typedef If_Else_<Arg1,Arg2,Arg3> type;
    };
};
If const if_then_else_;

template <class Condition,class Action1, class Enable=void >                                             
struct If_Then_ : euml_action<If_Then_<Condition,Action1,Enable> > {};

template <class Condition,class Action1>
struct If_Then_<Condition,Action1
    , typename ::boost::enable_if<typename has_tag_type<Action1>::type >::type>
    : euml_action<If_Then_<Condition,Action1> >
{
    template <class Event,class FSM,class STATE >
    struct state_action_result 
    {
        typedef typename get_result_type2<Action1,Event,FSM,STATE>::type type;
    };
    template <class EVT,class FSM,class SourceState,class TargetState>
    struct transition_action_result 
    {
        typedef typename get_result_type<Action1,EVT,FSM,SourceState,TargetState>::type type;
    };
    typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;

template <class EVT,class FSM,class SourceState,class TargetState>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename Action1::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
    {
        if (Condition()(evt,fsm,src,tgt))
        {
            return Action1()(evt,fsm,src,tgt);
        }
    }
    template <class Event,class FSM,class STATE>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename Action1::tag_type,state_action_tag>::type,
            typename state_action_result<Event,FSM,STATE>::type >::type 
     operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        if (Condition()(evt,fsm,state))
        {
            return Action1()(evt,fsm,state);
        }
    }
};

template <class Condition,class Action1>
struct If_Then_<Condition,Action1
    , typename ::boost::disable_if<typename has_tag_type<Action1>::type >::type>
    : euml_action<If_Then_<Condition,Action1> >
{
    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
    {
        if (Condition()(evt,fsm,src,tgt))
        {
            return Action1()(evt,fsm,src,tgt);
        }
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        if (Condition()(evt,fsm,state))
        {
            return Action1()(evt,fsm,state);
        }
    }
};
struct if_then_tag 
{
};
struct If_Then : proto::extends< proto::terminal<if_then_tag>::type, If_Then, boost::msm::sm_domain>
{
    If_Then(){}
    using proto::extends< proto::terminal<if_then_tag>::type, If_Then, boost::msm::sm_domain>::operator=;
    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
#ifdef BOOST_MSVC 
 ,class Arg6 
#endif
>
    struct In
    {
        typedef If_Then_<Arg1,Arg2> type;
    };
};
If_Then const if_then_;

template <class Condition,class Body>
struct While_Do_ : euml_action<While_Do_<Condition,Body> >
{
    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
    {
        Body body_;
        Condition cond_;
        while (cond_(evt,fsm,src,tgt))
        {
            body_(evt,fsm,src,tgt);
        }
    }
    template <class Event,class FSM,class STATE>
    void operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        Body body_;
        Condition cond_;
        while (cond_(evt,fsm,state))
        {
            body_(evt,fsm,state);
        }
    }
};
struct while_do_tag 
{
};
struct While_Do_Helper : proto::extends< proto::terminal<while_do_tag>::type, While_Do_Helper, boost::msm::sm_domain>
{
    While_Do_Helper(){}
    using proto::extends< proto::terminal<while_do_tag>::type, While_Do_Helper, boost::msm::sm_domain>::operator=;
    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
#ifdef BOOST_MSVC 
 ,class Arg6 
#endif
>
    struct In
    {
        typedef While_Do_<Arg1,Arg2> type;
    };
};
While_Do_Helper const while_;

template <class Condition,class Body>
struct Do_While_ : euml_action<Do_While_<Condition,Body> >
{
    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
    {
        Condition cond_;
        Body body_;
        do
        {
            body_(evt,fsm,src,tgt);
        } while (cond_(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    void operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        Condition cond_;
        Body body_;
        do
        {
            body_(evt,fsm,state);
        } while (cond_(evt,fsm,state));
    }
};
struct do_while_tag 
{
};
struct Do_While_Helper : proto::extends< proto::terminal<do_while_tag>::type, Do_While_Helper, boost::msm::sm_domain>
{
    Do_While_Helper(){}
    using proto::extends< proto::terminal<do_while_tag>::type, Do_While_Helper, boost::msm::sm_domain>::operator=;
    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
#ifdef BOOST_MSVC 
 ,class Arg6 
#endif
>
    struct In
    {
        typedef Do_While_<Arg1,Arg2> type;
    };
};
Do_While_Helper const do_while_;

template <class Begin,class End,class EndLoop,class Body>
struct For_Loop_ : euml_action<For_Loop_<Begin,End,EndLoop,Body> >
{
    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
    {
        End end_;
        EndLoop end_loop_;
        Body body_;
        for(Begin()(evt,fsm,src,tgt);end_(evt,fsm,src,tgt);end_loop_(evt,fsm,src,tgt))
        {
            body_(evt,fsm,src,tgt);
        }
    }
    template <class Event,class FSM,class STATE>
    void operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        End end_;
        EndLoop end_loop_;
        Body body_;
        for(Begin()(evt,fsm,state);end_(evt,fsm,state);end_loop_(evt,fsm,state))
        {
            body_(evt,fsm,state);
        }
    }
};
struct for_loop_tag 
{
};
struct For_Loop_Helper : proto::extends< proto::terminal<for_loop_tag>::type, For_Loop_Helper, boost::msm::sm_domain>
{
    For_Loop_Helper(){}
    using proto::extends< proto::terminal<for_loop_tag>::type, For_Loop_Helper, boost::msm::sm_domain>::operator=;
    template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
#ifdef BOOST_MSVC 
 ,class Arg6 
#endif
>
    struct In
    {
        typedef For_Loop_<Arg1,Arg2,Arg3,Arg4> type;
    };
};
For_Loop_Helper const for_;

template <class T>
struct Deref_ : euml_action<Deref_<T> >
{
    Deref_(){}
    using euml_action<Deref_<T> >::operator=;
    template <class Event,class FSM,class STATE >
    struct state_action_result 
    {
        typedef typename ::boost::add_reference<
                    typename std::iterator_traits <
                        typename ::boost::remove_reference<
                            typename get_result_type2<T,Event,FSM,STATE>::type>::type>::value_type>::type type;
    };
    template <class EVT,class FSM,class SourceState,class TargetState>
    struct transition_action_result 
    {
        typedef typename ::boost::add_reference<
                    typename std::iterator_traits< 
                        typename ::boost::remove_reference<
                            typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type
                    >::value_type
        >::type type;
    };
    typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;

template <class EVT,class FSM,class SourceState,class TargetState>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,action_tag>::type,
            typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    {
        return *(T()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,state_action_tag>::type,
            typename state_action_result<Event,FSM,STATE>::type >::type 
        operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        return *(T()(evt,fsm,state));
    }
};

template <class T>
struct Pre_inc_ : euml_action<Pre_inc_<T> >
{
    using euml_action<Pre_inc_<T> >::operator=;

template <class Event,class FSM,class STATE >
    struct state_action_result 
    {
        typedef typename get_result_type2<T,Event,FSM,STATE>::type type;
    };
    template <class EVT,class FSM,class SourceState,class TargetState>
    struct transition_action_result 
    {
        typedef typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type type;
    };
    typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;

template <class EVT,class FSM,class SourceState,class TargetState>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,action_tag>::type,
            typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    {
        return ++T()(evt,fsm,src,tgt);
    }
    template <class Event,class FSM,class STATE>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,state_action_tag>::type,
            typename state_action_result<Event,FSM,STATE>::type >::type 
        operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        return ++T()(evt,fsm,state);
    }
};
template <class T>
struct Pre_dec_ : euml_action<Pre_dec_<T> >
{
    using euml_action<Pre_dec_<T> >::operator=;

template <class EVT,class FSM,class SourceState,class TargetState>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,action_tag>::type,
            typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    {
        return --T()(evt,fsm,src,tgt);
    }
    template <class Event,class FSM,class STATE>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,state_action_tag>::type,
            typename state_action_result<Event,FSM,STATE>::type >::type 
        operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        return --T()(evt,fsm,state);
    }
};
template <class T>
struct Post_inc_ : euml_action<Post_inc_<T> >
{
    using euml_action<Post_inc_<T> >::operator=;

template <class Event,class FSM,class STATE >
    struct state_action_result 
    {
        typedef typename ::boost::remove_reference<
            typename get_result_type2<T,Event,FSM,STATE>::type>::type type;
    };
    template <class EVT,class FSM,class SourceState,class TargetState>
    struct transition_action_result 
    {
        typedef typename ::boost::remove_reference<
            typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type type;
    };
    typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;

template <class EVT,class FSM,class SourceState,class TargetState>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,action_tag>::type,
            typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    {
        return T()(evt,fsm,src,tgt)++;
    }
    template <class Event,class FSM,class STATE>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,state_action_tag>::type,
            typename state_action_result<Event,FSM,STATE>::type >::type
        operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        return T()(evt,fsm,state)++;
    }
};
template <class T>
struct Post_dec_ : euml_action<Post_dec_<T> >
{
    using euml_action<Post_dec_<T> >::operator=;

template <class EVT,class FSM,class SourceState,class TargetState>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,action_tag>::type,
            typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    {
        return T()(evt,fsm,src,tgt)--;
    }
    template <class Event,class FSM,class STATE>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T::tag_type,state_action_tag>::type,
            typename state_action_result<Event,FSM,STATE>::type >::type
        operator()(Event const& evt,FSM& fsm,STATE& state )const
    {
        return T()(evt,fsm,state)--;
    }
};

template <class T1,class T2>
struct Plus_ : euml_action<Plus_<T1,T2> >
{
    template <class Event,class FSM,class STATE >
    struct state_action_result 
    {
        typedef typename ::boost::remove_reference<
            typename get_result_type2<T1,Event,FSM,STATE>::type>::type type;
    };
    template <class EVT,class FSM,class SourceState,class TargetState>
    struct transition_action_result 
    {
        typedef typename ::boost::remove_reference<
            typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type type;
    };
    typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;

template <class EVT,class FSM,class SourceState,class TargetState>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T1::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 T1()(evt,fsm,src,tgt)^T2()(evt,fsm,src,tgt);
    }
    template <class Event,class FSM,class STATE>
    typename ::boost::enable_if<
        typename ::boost::mpl::has_key<
            typename T1::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 T1()(evt,fsm,state)^T2()(evt,fsm,state);
    }
};
template <class T1,class T2>
struct Subscript_ : euml_action<Subscript_<T1,T2> >
{
    template <class T>
    struct get_reference 
    {
        typedef typename T::reference type;
    };
    template <class T>
    struct get_mapped_type 
    {
        typedef typename T::value_type::second_type& type;
    };
    template <class Event,class FSM,class STATE >
    struct state_action_result 
    {
        typedef typename ::boost::remove_reference<
            typename get_result_type2<T1,Event,FSM,STATE>::type>::type container_type;
        typedef typename ::boost::mpl::eval_if<
            typename has_key_type<container_type>::type,
            get_mapped_type<container_type>,
            ::boost::mpl::eval_if<
                typename ::boost::is_pointer<container_type>::type,
                ::boost::add_reference<typename ::boost::remove_pointer<container_type>::type >,
                get_reference<container_type> 
             >
        >::type type;
    };
    template <class EVT,class FSM,class SourceState,class TargetState>
    struct transition_action_result 
    {
        typedef typename ::boost::remove_reference<
            typename get_result_type<T1,EVT,FSM,SourceState,TargetState>::type>::type container_type;
        typedef typename ::boost::mpl::eval_if<
            typename has_key_type<container_type>::type,
            get_mapped_type<container_type>,
            ::boost::mpl::eval_if<
                typename ::boost::is_pointer<container_type>::type,
                ::boost::add_reference<typename ::boost::remove_pointer<container_type>::type >,
                get_reference<container_type> 
             >
        >::type 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 (T1()(evt,fsm,src,tgt) < T2()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state)const
    {
        return (T1()(evt,fsm,state) < T2()(evt,fsm,state));
    }
};
template <class T1,class T2>
struct LessEqual_ : euml_action<LessEqual_<T1,T2> >
{
    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 (T1()(evt,fsm,src,tgt) <= T2()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state)const
    {
        return (T1()(evt,fsm,state) <= T2()(evt,fsm,state));
    }
};
template <class T1,class T2>
struct Greater_ : euml_action<Greater_<T1,T2> >
{
    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 (T1()(evt,fsm,src,tgt) > T2()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state)const
    {
        return (T1()(evt,fsm,state) > T2()(evt,fsm,state));
    }
};
template <class T1,class T2>
struct GreaterEqual_ : euml_action<GreaterEqual_<T1,T2> >
{
    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 (T1()(evt,fsm,src,tgt) >= T2()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state)const
    {
        return (T1()(evt,fsm,state) >= T2()(evt,fsm,state));
    }
};
template <class T1,class T2>
struct EqualTo_ : euml_action<EqualTo_<T1,T2> >
{
    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 (T1()(evt,fsm,src,tgt) == T2()(evt,fsm,src,tgt));
    }
    template <class Event,class FSM,class STATE>
    bool operator()(Event const& evt,FSM& fsm,STATE& state)const
    {
        return (T1()(evt,fsm,state) == T2()(evt,fsm,state));
    }
};
template <class T1,class T2>
struct NotEqualTo_ : euml_action<NotEqualTo_<T1,T2> >
{
    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;

}}}}

#endif // BOOST_MSM_FRONT_EUML_OPERATOR_H

// 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_OPERATOR_H #define BOOST_MSM_FRONT_EUML_OPERATOR_H #include #include #include #include #include #include #include #include BOOST_MPL_HAS_XXX_TRAIT_DEF(reference) BOOST_MPL_HAS_XXX_TRAIT_DEF(key_type) namespace boost { namespace msm { namespace front { namespace euml { template struct Or_ : euml_action > { template bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt) { return (T1()(evt,fsm,src,tgt) || T2()(evt,fsm,src,tgt)); } template bool operator()(Event const& evt,FSM& fsm,STATE& state) { return (T1()(evt,fsm,state) || T2()(evt,fsm,state)); } }; template struct And_ : euml_action > { template bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt) { return (T1()(evt,fsm,src,tgt) && T2()(evt,fsm,src,tgt)); } template bool operator()(Event const& evt,FSM& fsm,STATE& state) { return (T1()(evt,fsm,state) && T2()(evt,fsm,state)); } }; template struct Not_ : euml_action > { template bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt) { return !(T1()(evt,fsm,src,tgt)); } template bool operator()(Event const& evt,FSM& fsm,STATE& state) { return !(T1()(evt,fsm,state)); } }; template struct If_Else_ : euml_action > {}; template struct If_Else_::type >::type> : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename Action1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { if (Condition()(evt,fsm,src,tgt)) { return Action1()(evt,fsm,src,tgt); } return Action2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename Action1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { if (Condition()(evt,fsm,state)) { return Action1()(evt,fsm,state); } return Action2()(evt,fsm,state); } }; template struct If_Else_::type >::type> : euml_action > { template struct state_action_result { typedef bool type; }; template struct transition_action_result { typedef bool type; }; typedef ::boost::mpl::set tag_type; template bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { if (Condition()(evt,fsm,src,tgt)) { return Action1()(evt,fsm,src,tgt); } return Action2()(evt,fsm,src,tgt); } template bool operator()(Event const& evt,FSM& fsm,STATE& state )const { if (Condition()(evt,fsm,state)) { return Action1()(evt,fsm,state); } return Action2()(evt,fsm,state); } }; struct if_tag { }; struct If : proto::extends::type, If, boost::msm::sm_domain> { If(){} using proto::extends< proto::terminal::type, If, boost::msm::sm_domain>::operator=; template struct In { typedef If_Else_ type; }; }; If const if_then_else_; template struct If_Then_ : euml_action > {}; template struct If_Then_::type >::type> : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename Action1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { if (Condition()(evt,fsm,src,tgt)) { return Action1()(evt,fsm,src,tgt); } } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename Action1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { if (Condition()(evt,fsm,state)) { return Action1()(evt,fsm,state); } } }; template struct If_Then_::type >::type> : euml_action > { template struct state_action_result { typedef bool type; }; template struct transition_action_result { typedef bool type; }; typedef ::boost::mpl::set tag_type; template bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { if (Condition()(evt,fsm,src,tgt)) { return Action1()(evt,fsm,src,tgt); } } template bool operator()(Event const& evt,FSM& fsm,STATE& state )const { if (Condition()(evt,fsm,state)) { return Action1()(evt,fsm,state); } } }; struct if_then_tag { }; struct If_Then : proto::extends< proto::terminal::type, If_Then, boost::msm::sm_domain> { If_Then(){} using proto::extends< proto::terminal::type, If_Then, boost::msm::sm_domain>::operator=; template struct In { typedef If_Then_ type; }; }; If_Then const if_then_; template struct While_Do_ : euml_action > { template struct state_action_result { typedef void type; }; template struct transition_action_result { typedef void type; }; typedef ::boost::mpl::set tag_type; template void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { Body body_; Condition cond_; while (cond_(evt,fsm,src,tgt)) { body_(evt,fsm,src,tgt); } } template void operator()(Event const& evt,FSM& fsm,STATE& state )const { Body body_; Condition cond_; while (cond_(evt,fsm,state)) { body_(evt,fsm,state); } } }; struct while_do_tag { }; struct While_Do_Helper : proto::extends< proto::terminal::type, While_Do_Helper, boost::msm::sm_domain> { While_Do_Helper(){} using proto::extends< proto::terminal::type, While_Do_Helper, boost::msm::sm_domain>::operator=; template struct In { typedef While_Do_ type; }; }; While_Do_Helper const while_; template struct Do_While_ : euml_action > { template struct state_action_result { typedef void type; }; template struct transition_action_result { typedef void type; }; typedef ::boost::mpl::set tag_type; template void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { Condition cond_; Body body_; do { body_(evt,fsm,src,tgt); } while (cond_(evt,fsm,src,tgt)); } template void operator()(Event const& evt,FSM& fsm,STATE& state )const { Condition cond_; Body body_; do { body_(evt,fsm,state); } while (cond_(evt,fsm,state)); } }; struct do_while_tag { }; struct Do_While_Helper : proto::extends< proto::terminal::type, Do_While_Helper, boost::msm::sm_domain> { Do_While_Helper(){} using proto::extends< proto::terminal::type, Do_While_Helper, boost::msm::sm_domain>::operator=; template struct In { typedef Do_While_ type; }; }; Do_While_Helper const do_while_; template struct For_Loop_ : euml_action > { template struct state_action_result { typedef void type; }; template struct transition_action_result { typedef void type; }; typedef ::boost::mpl::set tag_type; template void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { End end_; EndLoop end_loop_; Body body_; for(Begin()(evt,fsm,src,tgt);end_(evt,fsm,src,tgt);end_loop_(evt,fsm,src,tgt)) { body_(evt,fsm,src,tgt); } } template void operator()(Event const& evt,FSM& fsm,STATE& state )const { End end_; EndLoop end_loop_; Body body_; for(Begin()(evt,fsm,state);end_(evt,fsm,state);end_loop_(evt,fsm,state)) { body_(evt,fsm,state); } } }; struct for_loop_tag { }; struct For_Loop_Helper : proto::extends< proto::terminal::type, For_Loop_Helper, boost::msm::sm_domain> { For_Loop_Helper(){} using proto::extends< proto::terminal::type, For_Loop_Helper, boost::msm::sm_domain>::operator=; template struct In { typedef For_Loop_ type; }; }; For_Loop_Helper const for_; template struct Deref_ : euml_action > { Deref_(){} using euml_action >::operator=; template struct state_action_result { typedef typename ::boost::add_reference< typename std::iterator_traits < typename ::boost::remove_reference< typename get_result_type2::type>::type>::value_type>::type type; }; template struct transition_action_result { typedef typename ::boost::add_reference< typename std::iterator_traits< typename ::boost::remove_reference< typename get_result_type::type>::type >::value_type >::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return *(T()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return *(T()(evt,fsm,state)); } }; template struct Pre_inc_ : euml_action > { using euml_action >::operator=; template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return ++T()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return ++T()(evt,fsm,state); } }; template struct Pre_dec_ : euml_action > { using euml_action >::operator=; template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return --T()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return --T()(evt,fsm,state); } }; template struct Post_inc_ : euml_action > { using euml_action >::operator=; template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T()(evt,fsm,src,tgt)++; } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T()(evt,fsm,state)++; } }; template struct Post_dec_ : euml_action > { using euml_action >::operator=; template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T()(evt,fsm,src,tgt)--; } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T()(evt,fsm,state)--; } }; template struct Plus_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)+T2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)+T2()(evt,fsm,state); } }; template struct Minus_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)-T2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)-T2()(evt,fsm,state); } }; template struct Multiplies_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)*T2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)*T2()(evt,fsm,state); } }; template struct Divides_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)/T2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)/T2()(evt,fsm,state); } }; template struct Modulus_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)%T2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)%T2()(evt,fsm,state); } }; template struct Bitwise_And_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)&T2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)&T2()(evt,fsm,state); } }; template struct Bitwise_Or_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)|T2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)|T2()(evt,fsm,state); } }; template struct Bitwise_Xor_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)^T2()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)^T2()(evt,fsm,state); } }; template struct Subscript_ : euml_action > { template struct get_reference { typedef typename T::reference type; }; template struct get_mapped_type { typedef typename T::value_type::second_type& type; }; template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type container_type; typedef typename ::boost::mpl::eval_if< typename has_key_type::type, get_mapped_type, ::boost::mpl::eval_if< typename ::boost::is_pointer::type, ::boost::add_reference::type >, get_reference > >::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type container_type; typedef typename ::boost::mpl::eval_if< typename has_key_type::type, get_mapped_type, ::boost::mpl::eval_if< typename ::boost::is_pointer::type, ::boost::add_reference::type >, get_reference > >::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return T1()(evt,fsm,src,tgt)[T2()(evt,fsm,src,tgt)]; } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return T1()(evt,fsm,state)[T2()(evt,fsm,state)]; } }; template struct Plus_Assign_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)+=T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)+=T2()(evt,fsm,state)); } }; template struct Minus_Assign_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)-=T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)-=T2()(evt,fsm,state)); } }; template struct Multiplies_Assign_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)*=T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)*=T2()(evt,fsm,state)); } }; template struct Divides_Assign_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)/=T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)/=T2()(evt,fsm,state)); } }; template struct Modulus_Assign_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)%=T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)%=T2()(evt,fsm,state)); } }; template struct ShiftLeft_Assign_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)<<=T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)<<=T2()(evt,fsm,state)); } }; template struct ShiftRight_Assign_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)>>=T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)>>=T2()(evt,fsm,state)); } }; template struct ShiftLeft_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)< typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)< struct ShiftRight_ : euml_action > { template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)>>T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)>>T2()(evt,fsm,state)); } }; template struct Assign_ : euml_action > { using euml_action< Assign_ >::operator=; template struct state_action_result { typedef typename get_result_type2::type type; }; template struct transition_action_result { typedef typename get_result_type::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return (T1()(evt,fsm,src,tgt)=T2()(evt,fsm,src,tgt)); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return (T1()(evt,fsm,state)=T2()(evt,fsm,state)); } }; template struct Unary_Plus_ : euml_action > { template struct state_action_result { typedef typename ::boost::remove_reference< typename get_result_type2::type>::type type; }; template struct transition_action_result { typedef typename ::boost::remove_reference< typename get_result_type::type>::type type; }; typedef ::boost::mpl::set tag_type; template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,action_tag>::type, typename transition_action_result::type >::type operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const { return +T1()(evt,fsm,src,tgt); } template typename ::boost::enable_if< typename ::boost::mpl::has_key< typename T1::tag_type,state_action_tag>::type, typename state_action_result::type >::type operator()(Event const& evt,FSM& fsm,STATE& state )const { return +T1()(evt,fsm,state); } }; template struct Unary_Minus_ : euml_action > { template