front/euml/container.hpp

0001 // Copyright 2008 Christophe Henry
0002 // henry UNDERSCORE christophe AT hotmail DOT com
0003 // This is an extended version of the state machine available in the boost::mpl library
0004 // Distributed under the same license as the original.
0005 // Copyright for the original version:
0006 // Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
0007 // under the Boost Software License, Version 1.0. (See accompanying
0008 // file LICENSE_1_0.txt or copy at
0009 // http://www.boost.org/LICENSE_1_0.txt)
0010
0011 #ifndef BOOST_MSM_FRONT_EUML_CONTAINER_H
0012 #define BOOST_MSM_FRONT_EUML_CONTAINER_H
0013
0014 #include <utility>
0015 #include <boost/msm/front/euml/common.hpp>
0016 #include <boost/utility/enable_if.hpp>
0017 #include <boost/mpl/has_key.hpp>
0018 #include <boost/mpl/set.hpp>
0019 #include <boost/mpl/not.hpp>
0020 #include <boost/msm/front/euml/operator.hpp>
0021 #include <boost/type_traits.hpp>
0022 #include <boost/fusion/container/set.hpp>
0023
0024
0025 BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
0026
0027 namespace boost { namespace msm { namespace front { namespace euml
0028 {
0029
0030 template <class T>
0031 struct Front_ : euml_action<Front_<T> >
0032 {
0033     template <class Event,class FSM,class STATE >
0034     struct state_action_result
0035     {
0036         typedef typename get_reference<
0037             typename ::boost::remove_reference<
0038                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
0039     };
0040     template <class EVT,class FSM,class SourceState,class TargetState>
0041     struct transition_action_result
0042     {
0043         typedef typename get_reference<
0044             typename ::boost::remove_reference<
0045                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0046     };
0047     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0048
0049     template <class EVT,class FSM,class SourceState,class TargetState>
0050     typename ::boost::enable_if<
0051         typename ::boost::mpl::has_key<
0052             typename T::tag_type,action_tag>::type,
0053             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0054         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0055     {
0056         return (T()(evt,fsm,src,tgt)).front();
0057     }
0058     template <class Event,class FSM,class STATE>
0059     typename ::boost::enable_if<
0060         typename ::boost::mpl::has_key<
0061             typename T::tag_type,state_action_tag>::type,
0062             typename state_action_result<Event,FSM,STATE>::type >::type
0063         operator()(Event const& evt,FSM& fsm,STATE& state )const
0064     {
0065         return (T()(evt,fsm,state)).front();
0066     }
0067 };
0068
0069 struct front_tag {};
0070 struct Front_Helper: proto::extends< proto::terminal<front_tag>::type, Front_Helper, boost::msm::sm_domain>
0071 {
0072     Front_Helper(){}
0073     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0074 #ifdef BOOST_MSVC
0075  ,class Arg6
0076 #endif
0077 >
0078     struct In
0079     {
0080         typedef Front_<Arg1> type;
0081     };
0082 };
0083 Front_Helper const front_;
0084
0085 template <class T>
0086 struct Back_ : euml_action<Back_<T> >
0087 {
0088     template <class Event,class FSM,class STATE >
0089     struct state_action_result
0090     {
0091         typedef typename get_reference<
0092             typename ::boost::remove_reference<
0093                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
0094     };
0095     template <class EVT,class FSM,class SourceState,class TargetState>
0096     struct transition_action_result
0097     {
0098         typedef typename get_reference<
0099             typename ::boost::remove_reference<
0100                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0101     };
0102     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0103
0104     template <class EVT,class FSM,class SourceState,class TargetState>
0105     typename ::boost::enable_if<
0106         typename ::boost::mpl::has_key<
0107             typename T::tag_type,action_tag>::type,
0108             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0109         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0110     {
0111         return (T()(evt,fsm,src,tgt)).back();
0112     }
0113     template <class Event,class FSM,class STATE>
0114     typename ::boost::enable_if<
0115         typename ::boost::mpl::has_key<
0116             typename T::tag_type,state_action_tag>::type,
0117             typename state_action_result<Event,FSM,STATE>::type >::type
0118         operator()(Event const& evt,FSM& fsm,STATE& state )const
0119     {
0120         return (T()(evt,fsm,state)).back();
0121     }
0122 };
0123
0124 struct back_tag {};
0125 struct Back_Helper: proto::extends< proto::terminal<back_tag>::type, Back_Helper, boost::msm::sm_domain>
0126 {
0127     Back_Helper(){}
0128     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0129 #ifdef BOOST_MSVC
0130  ,class Arg6
0131 #endif
0132 >
0133     struct In
0134     {
0135         typedef Back_<Arg1> type;
0136     };
0137 };
0138 Back_Helper const back_;
0139
0140 template <class T>
0141 struct Begin_ : euml_action<Begin_<T> >
0142 {
0143     template <class Event,class FSM,class STATE >
0144     struct state_action_result
0145     {
0146         typedef typename get_iterator<
0147             typename ::boost::remove_reference<
0148                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
0149     };
0150     template <class EVT,class FSM,class SourceState,class TargetState>
0151     struct transition_action_result
0152     {
0153         typedef typename get_iterator<
0154             typename ::boost::remove_reference<
0155                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0156     };
0157     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0158
0159     template <class EVT,class FSM,class SourceState,class TargetState>
0160     typename ::boost::enable_if<
0161         typename ::boost::mpl::has_key<
0162             typename T::tag_type,action_tag>::type,
0163             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0164         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0165     {
0166         return (T()(evt,fsm,src,tgt)).begin();
0167     }
0168     template <class Event,class FSM,class STATE>
0169     typename ::boost::enable_if<
0170         typename ::boost::mpl::has_key<
0171             typename T::tag_type,state_action_tag>::type,
0172             typename state_action_result<Event,FSM,STATE>::type >::type
0173         operator()(Event const& evt,FSM& fsm,STATE& state )const
0174     {
0175         return (T()(evt,fsm,state)).begin();
0176     }
0177 };
0178
0179 struct begin_tag {};
0180 struct Begin_Helper: proto::extends< proto::terminal<begin_tag>::type, Begin_Helper, boost::msm::sm_domain>
0181 {
0182     Begin_Helper(){}
0183     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0184 #ifdef BOOST_MSVC
0185  ,class Arg6
0186 #endif
0187 >
0188     struct In
0189     {
0190         typedef Begin_<Arg1> type;
0191     };
0192 };
0193 Begin_Helper const begin_;
0194
0195 template <class T>
0196 struct End_ : euml_action<End_<T> >
0197 {
0198     template <class Event,class FSM,class STATE >
0199     struct state_action_result
0200     {
0201         typedef typename get_iterator<
0202             typename ::boost::remove_reference<
0203                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
0204     };
0205     template <class EVT,class FSM,class SourceState,class TargetState>
0206     struct transition_action_result
0207     {
0208         typedef typename get_iterator<
0209             typename ::boost::remove_reference<
0210                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0211     };
0212     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0213
0214     template <class EVT,class FSM,class SourceState,class TargetState>
0215     typename ::boost::enable_if<
0216         typename ::boost::mpl::has_key<
0217             typename T::tag_type,action_tag>::type,
0218             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0219         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0220     {
0221         return (T()(evt,fsm,src,tgt)).end();
0222     }
0223     template <class Event,class FSM,class STATE>
0224     typename ::boost::enable_if<
0225         typename ::boost::mpl::has_key<
0226             typename T::tag_type,state_action_tag>::type,
0227             typename state_action_result<Event,FSM,STATE>::type >::type
0228         operator()(Event const& evt,FSM& fsm,STATE& state )const
0229     {
0230         return (T()(evt,fsm,state)).end();
0231     }
0232 };
0233 struct end_tag {};
0234 struct End_Helper: proto::extends< proto::terminal<end_tag>::type, End_Helper, boost::msm::sm_domain>
0235 {
0236     End_Helper(){}
0237     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0238 #ifdef BOOST_MSVC
0239  ,class Arg6
0240 #endif
0241 >
0242     struct In
0243     {
0244         typedef End_<Arg1> type;
0245     };
0246 };
0247 End_Helper const end_;
0248
0249 template <class T>
0250 struct RBegin_ : euml_action<RBegin_<T> >
0251 {
0252     template <class Event,class FSM,class STATE >
0253     struct state_action_result
0254     {
0255         typedef typename get_reverse_iterator<
0256             typename ::boost::remove_reference<
0257                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
0258     };
0259     template <class EVT,class FSM,class SourceState,class TargetState>
0260     struct transition_action_result
0261     {
0262         typedef typename get_reverse_iterator<
0263             typename ::boost::remove_reference<
0264                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0265     };
0266     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0267
0268     template <class EVT,class FSM,class SourceState,class TargetState>
0269     typename ::boost::enable_if<
0270         typename ::boost::mpl::has_key<
0271             typename T::tag_type,action_tag>::type,
0272             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0273         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0274     {
0275         return (T()(evt,fsm,src,tgt)).rbegin();
0276     }
0277     template <class Event,class FSM,class STATE>
0278     typename ::boost::enable_if<
0279         typename ::boost::mpl::has_key<
0280             typename T::tag_type,state_action_tag>::type,
0281             typename state_action_result<Event,FSM,STATE>::type >::type
0282         operator()(Event const& evt,FSM& fsm,STATE& state )const
0283     {
0284         return (T()(evt,fsm,state)).rbegin();
0285     }
0286 };
0287
0288 struct rbegin_tag {};
0289 struct RBegin_Helper: proto::extends< proto::terminal<rbegin_tag>::type, RBegin_Helper, boost::msm::sm_domain>
0290 {
0291     RBegin_Helper(){}
0292     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0293 #ifdef BOOST_MSVC
0294  ,class Arg6
0295 #endif
0296 >
0297     struct In
0298     {
0299         typedef RBegin_<Arg1> type;
0300     };
0301 };
0302 RBegin_Helper const rbegin_;
0303
0304 template <class T>
0305 struct REnd_ : euml_action<REnd_<T> >
0306 {
0307     template <class Event,class FSM,class STATE >
0308     struct state_action_result
0309     {
0310         typedef typename get_reverse_iterator<
0311             typename ::boost::remove_reference<
0312                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
0313     };
0314     template <class EVT,class FSM,class SourceState,class TargetState>
0315     struct transition_action_result
0316     {
0317         typedef typename get_reverse_iterator<
0318             typename ::boost::remove_reference<
0319                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0320     };
0321     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0322
0323     template <class EVT,class FSM,class SourceState,class TargetState>
0324     typename ::boost::enable_if<
0325         typename ::boost::mpl::has_key<
0326             typename T::tag_type,action_tag>::type,
0327             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0328         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0329     {
0330         return (T()(evt,fsm,src,tgt)).rend();
0331     }
0332     template <class Event,class FSM,class STATE>
0333     typename ::boost::enable_if<
0334         typename ::boost::mpl::has_key<
0335             typename T::tag_type,state_action_tag>::type,
0336             typename state_action_result<Event,FSM,STATE>::type >::type
0337         operator()(Event const& evt,FSM& fsm,STATE& state )const
0338     {
0339         return (T()(evt,fsm,state)).rend();
0340     }
0341 };
0342 struct rend_tag {};
0343 struct REnd_Helper: proto::extends< proto::terminal<rend_tag>::type, REnd_Helper, boost::msm::sm_domain>
0344 {
0345     REnd_Helper(){}
0346     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0347 #ifdef BOOST_MSVC
0348  ,class Arg6
0349 #endif
0350 >
0351     struct In
0352     {
0353         typedef REnd_<Arg1> type;
0354     };
0355 };
0356 REnd_Helper const rend_;
0357
0358 template <class Container,class Element>
0359 struct Push_Back_ : euml_action<Push_Back_<Container,Element> >
0360 {
0361     template <class Event,class FSM,class STATE >
0362     struct state_action_result
0363     {
0364         typedef void type;
0365     };
0366     template <class EVT,class FSM,class SourceState,class TargetState>
0367     struct transition_action_result
0368     {
0369         typedef void type;
0370     };
0371     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0372
0373     template <class EVT,class FSM,class SourceState,class TargetState>
0374     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0375     {
0376         (Container()(evt,fsm,src,tgt)).push_back(Element()(evt,fsm,src,tgt));
0377     }
0378     template <class Event,class FSM,class STATE>
0379     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0380     {
0381         (Container()(evt,fsm,state)).push_back(Element()(evt,fsm,state));
0382     }
0383 };
0384 struct push_back_tag {};
0385 struct Push_Back_Helper: proto::extends< proto::terminal<push_back_tag>::type, Push_Back_Helper, boost::msm::sm_domain>
0386 {
0387     Push_Back_Helper(){}
0388     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0389 #ifdef BOOST_MSVC
0390  ,class Arg6
0391 #endif
0392 >
0393     struct In
0394     {
0395         typedef Push_Back_<Arg1,Arg2> type;
0396     };
0397 };
0398 Push_Back_Helper const push_back_;
0399
0400 template <class Container>
0401 struct Pop_Back_ : euml_action<Pop_Back_<Container> >
0402 {
0403     template <class Event,class FSM,class STATE >
0404     struct state_action_result
0405     {
0406         typedef void type;
0407     };
0408     template <class EVT,class FSM,class SourceState,class TargetState>
0409     struct transition_action_result
0410     {
0411         typedef void type;
0412     };
0413     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0414
0415     template <class EVT,class FSM,class SourceState,class TargetState>
0416     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0417     {
0418         (Container()(evt,fsm,src,tgt)).pop_back();
0419     }
0420     template <class Event,class FSM,class STATE>
0421     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0422     {
0423         (Container()(evt,fsm,state)).pop_back();
0424     }
0425 };
0426 struct pop_back_tag {};
0427 struct Pop_Back_Helper: proto::extends< proto::terminal<pop_back_tag>::type, Pop_Back_Helper, boost::msm::sm_domain>
0428 {
0429     Pop_Back_Helper(){}
0430     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0431 #ifdef BOOST_MSVC
0432  ,class Arg6
0433 #endif
0434 >
0435     struct In
0436     {
0437         typedef Pop_Back_<Arg1> type;
0438     };
0439 };
0440 Pop_Back_Helper const pop_back_;
0441
0442 template <class Container,class Element>
0443 struct Push_Front_ : euml_action<Push_Front_<Container,Element> >
0444 {
0445     template <class Event,class FSM,class STATE >
0446     struct state_action_result
0447     {
0448         typedef void type;
0449     };
0450     template <class EVT,class FSM,class SourceState,class TargetState>
0451     struct transition_action_result
0452     {
0453         typedef void type;
0454     };
0455     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0456
0457     template <class EVT,class FSM,class SourceState,class TargetState>
0458     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0459     {
0460         (Container()(evt,fsm,src,tgt)).push_front(Element()(evt,fsm,src,tgt));
0461     }
0462     template <class Event,class FSM,class STATE>
0463     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0464     {
0465         (Container()(evt,fsm,state)).push_front(Element()(evt,fsm,state));
0466     }
0467 };
0468 struct push_front_tag {};
0469 struct Push_Front_Helper: proto::extends< proto::terminal<push_front_tag>::type, Push_Front_Helper, boost::msm::sm_domain>
0470 {
0471     Push_Front_Helper(){}
0472     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0473 #ifdef BOOST_MSVC
0474  ,class Arg6
0475 #endif
0476 >
0477     struct In
0478     {
0479         typedef Push_Front_<Arg1,Arg2> type;
0480     };
0481 };
0482 Push_Front_Helper const push_front_;
0483
0484 template <class Container>
0485 struct Pop_Front_ : euml_action<Pop_Front_<Container> >
0486 {
0487     template <class Event,class FSM,class STATE >
0488     struct state_action_result
0489     {
0490         typedef void type;
0491     };
0492     template <class EVT,class FSM,class SourceState,class TargetState>
0493     struct transition_action_result
0494     {
0495         typedef void type;
0496     };
0497     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0498
0499     template <class EVT,class FSM,class SourceState,class TargetState>
0500     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0501     {
0502         (Container()(evt,fsm,src,tgt)).pop_front();
0503     }
0504     template <class Event,class FSM,class STATE>
0505     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0506     {
0507         (Container()(evt,fsm,state)).pop_front();
0508     }
0509 };
0510 struct pop_front_tag {};
0511 struct Pop_Front_Helper: proto::extends< proto::terminal<pop_front_tag>::type, Pop_Front_Helper, boost::msm::sm_domain>
0512 {
0513     Pop_Front_Helper(){}
0514     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0515 #ifdef BOOST_MSVC
0516  ,class Arg6
0517 #endif
0518 >
0519     struct In
0520     {
0521         typedef Pop_Front_<Arg1> type;
0522     };
0523 };
0524 Pop_Front_Helper const pop_front_;
0525
0526 template <class Container>
0527 struct Clear_ : euml_action<Clear_<Container> >
0528 {
0529     template <class Event,class FSM,class STATE >
0530     struct state_action_result
0531     {
0532         typedef void type;
0533     };
0534     template <class EVT,class FSM,class SourceState,class TargetState>
0535     struct transition_action_result
0536     {
0537         typedef void type;
0538     };
0539     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0540
0541     template <class EVT,class FSM,class SourceState,class TargetState>
0542     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0543     {
0544         (Container()(evt,fsm,src,tgt)).clear();
0545     }
0546     template <class Event,class FSM,class STATE>
0547     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0548     {
0549         (Container()(evt,fsm,state)).clear();
0550     }
0551 };
0552 struct clear_tag {};
0553 struct Clear_Helper: proto::extends< proto::terminal<clear_tag>::type, Clear_Helper, boost::msm::sm_domain>
0554 {
0555     Clear_Helper(){}
0556     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0557 #ifdef BOOST_MSVC
0558  ,class Arg6
0559 #endif
0560 >
0561     struct In
0562     {
0563         typedef Clear_<Arg1> type;
0564     };
0565 };
0566 Clear_Helper const clear_;
0567
0568 template <class Container>
0569 struct ListReverse_ : euml_action<ListReverse_<Container> >
0570 {
0571     template <class Event,class FSM,class STATE >
0572     struct state_action_result
0573     {
0574         typedef void type;
0575     };
0576     template <class EVT,class FSM,class SourceState,class TargetState>
0577     struct transition_action_result
0578     {
0579         typedef void type;
0580     };
0581     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0582
0583     template <class EVT,class FSM,class SourceState,class TargetState>
0584     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0585     {
0586         (Container()(evt,fsm,src,tgt)).reverse();
0587     }
0588     template <class Event,class FSM,class STATE>
0589     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0590     {
0591         (Container()(evt,fsm,state)).reverse();
0592     }
0593 };
0594 struct list_reverse_tag {};
0595 struct ListReverse_Helper: proto::extends< proto::terminal<list_reverse_tag>::type, ListReverse_Helper, boost::msm::sm_domain>
0596 {
0597     ListReverse_Helper(){}
0598     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0599 #ifdef BOOST_MSVC
0600  ,class Arg6
0601 #endif
0602 >
0603     struct In
0604     {
0605         typedef ListReverse_<Arg1> type;
0606     };
0607 };
0608 ListReverse_Helper const list_reverse_;
0609
0610 template <class Container, class Predicate, class Enable=void>
0611 struct ListUnique_ : euml_action<ListUnique_<Container,Predicate,Enable> >
0612 {
0613     template <class Event,class FSM,class STATE >
0614     struct state_action_result
0615     {
0616         typedef void type;
0617     };
0618     template <class EVT,class FSM,class SourceState,class TargetState>
0619     struct transition_action_result
0620     {
0621         typedef void type;
0622     };
0623     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0624
0625     template <class EVT,class FSM,class SourceState,class TargetState>
0626     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0627     {
0628         (Container()(evt,fsm,src,tgt)).unique();
0629     }
0630     template <class Event,class FSM,class STATE>
0631     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0632     {
0633         (Container()(evt,fsm,state)).unique();
0634     }
0635 };
0636 template <class Container, class Predicate >
0637 struct ListUnique_<Container,Predicate,
0638                typename ::boost::disable_if<typename ::boost::is_same<Predicate,void>::type >::type>
0639                     : euml_action<ListUnique_<Container,Predicate> >
0640 {
0641     template <class Event,class FSM,class STATE >
0642     struct state_action_result
0643     {
0644         typedef void type;
0645     };
0646     template <class EVT,class FSM,class SourceState,class TargetState>
0647     struct transition_action_result
0648     {
0649         typedef void type;
0650     };
0651     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0652
0653     template <class EVT,class FSM,class SourceState,class TargetState>
0654     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0655     {
0656         (Container()(evt,fsm,src,tgt)).unique(Predicate()(evt,fsm,src,tgt));
0657     }
0658     template <class Event,class FSM,class STATE>
0659     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0660     {
0661         (Container()(evt,fsm,state)).unique(Predicate()(evt,fsm,state));
0662     }
0663 };
0664 struct list_unique_tag {};
0665 struct ListUnique_Helper: proto::extends< proto::terminal<list_unique_tag>::type, ListUnique_Helper, boost::msm::sm_domain>
0666 {
0667     ListUnique_Helper(){}
0668     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0669 #ifdef BOOST_MSVC
0670  ,class Arg6
0671 #endif
0672 >
0673     struct In
0674     {
0675         typedef ListUnique_<Arg1,Arg2> type;
0676     };
0677 };
0678 ListUnique_Helper const list_unique_;
0679
0680 template <class Container, class Predicate, class Enable=void>
0681 struct ListSort_ : euml_action<ListSort_<Container,Predicate,Enable> >
0682 {
0683     template <class Event,class FSM,class STATE >
0684     struct state_action_result
0685     {
0686         typedef void type;
0687     };
0688     template <class EVT,class FSM,class SourceState,class TargetState>
0689     struct transition_action_result
0690     {
0691         typedef void type;
0692     };
0693     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0694
0695     template <class EVT,class FSM,class SourceState,class TargetState>
0696     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0697     {
0698         (Container()(evt,fsm,src,tgt)).sort();
0699     }
0700     template <class Event,class FSM,class STATE>
0701     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0702     {
0703         (Container()(evt,fsm,state)).sort();
0704     }
0705 };
0706 template <class Container, class Predicate >
0707 struct ListSort_<Container,Predicate,
0708                typename ::boost::disable_if<typename ::boost::is_same<Predicate,void>::type >::type>
0709                     : euml_action<ListSort_<Container,Predicate> >
0710 {
0711     template <class Event,class FSM,class STATE >
0712     struct state_action_result
0713     {
0714         typedef void type;
0715     };
0716     template <class EVT,class FSM,class SourceState,class TargetState>
0717     struct transition_action_result
0718     {
0719         typedef void type;
0720     };
0721     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0722
0723     template <class EVT,class FSM,class SourceState,class TargetState>
0724     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0725     {
0726         (Container()(evt,fsm,src,tgt)).sort(Predicate()(evt,fsm,src,tgt));
0727     }
0728     template <class Event,class FSM,class STATE>
0729     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0730     {
0731         (Container()(evt,fsm,state)).sort(Predicate()(evt,fsm,state));
0732     }
0733 };
0734 struct list_sort_tag {};
0735 struct ListSort_Helper: proto::extends< proto::terminal<list_sort_tag>::type, ListSort_Helper, boost::msm::sm_domain>
0736 {
0737     ListSort_Helper(){}
0738     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0739 #ifdef BOOST_MSVC
0740  ,class Arg6
0741 #endif
0742 >
0743     struct In
0744     {
0745         typedef ListSort_<Arg1,Arg2> type;
0746     };
0747 };
0748 ListSort_Helper const list_sort_;
0749
0750 template <class Container>
0751 struct Capacity_ : euml_action<Capacity_<Container> >
0752 {
0753     template <class Event,class FSM,class STATE >
0754     struct state_action_result
0755     {
0756         typedef typename get_size_type<
0757             typename ::boost::remove_reference<
0758                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
0759     };
0760     template <class EVT,class FSM,class SourceState,class TargetState>
0761     struct transition_action_result
0762     {
0763         typedef typename get_size_type<
0764             typename ::boost::remove_reference<
0765                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0766     };
0767     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0768
0769     template <class EVT,class FSM,class SourceState,class TargetState>
0770     typename ::boost::enable_if<
0771         typename ::boost::mpl::has_key<
0772             typename Container::tag_type,action_tag>::type,
0773             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0774      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0775     {
0776         return (Container()(evt,fsm,src,tgt)).capacity();
0777     }
0778     template <class Event,class FSM,class STATE>
0779     typename ::boost::enable_if<
0780         typename ::boost::mpl::has_key<
0781             typename Container::tag_type,state_action_tag>::type,
0782             typename state_action_result<Event,FSM,STATE>::type >::type
0783      operator()(Event const& evt,FSM& fsm,STATE& state )const
0784     {
0785         return (Container()(evt,fsm,state)).capacity();
0786     }
0787 };
0788 struct capacity_tag {};
0789 struct Capacity_Helper: proto::extends< proto::terminal<capacity_tag>::type, Capacity_Helper, boost::msm::sm_domain>
0790 {
0791     Capacity_Helper(){}
0792     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0793 #ifdef BOOST_MSVC
0794  ,class Arg6
0795 #endif
0796 >
0797     struct In
0798     {
0799         typedef Capacity_<Arg1> type;
0800     };
0801 };
0802 Capacity_Helper const capacity_;
0803
0804 template <class Container>
0805 struct Size_ : euml_action<Size_<Container> >
0806 {
0807     template <class Event,class FSM,class STATE >
0808     struct state_action_result
0809     {
0810         typedef typename get_size_type<
0811             typename ::boost::remove_reference<
0812                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
0813     };
0814     template <class EVT,class FSM,class SourceState,class TargetState>
0815     struct transition_action_result
0816     {
0817         typedef typename get_size_type<
0818             typename ::boost::remove_reference<
0819                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0820     };
0821     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0822
0823     template <class EVT,class FSM,class SourceState,class TargetState>
0824     typename ::boost::enable_if<
0825         typename ::boost::mpl::has_key<
0826             typename Container::tag_type,action_tag>::type,
0827             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0828      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0829     {
0830         return (Container()(evt,fsm,src,tgt)).size();
0831     }
0832     template <class Event,class FSM,class STATE>
0833     typename ::boost::enable_if<
0834         typename ::boost::mpl::has_key<
0835             typename Container::tag_type,state_action_tag>::type,
0836             typename state_action_result<Event,FSM,STATE>::type >::type
0837      operator()(Event const& evt,FSM& fsm,STATE& state )const
0838     {
0839         return (Container()(evt,fsm,state)).size();
0840     }
0841 };
0842 struct size_tag {};
0843 struct Size_Helper: proto::extends< proto::terminal<size_tag>::type, Size_Helper, boost::msm::sm_domain>
0844 {
0845     Size_Helper(){}
0846     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0847 #ifdef BOOST_MSVC
0848  ,class Arg6
0849 #endif
0850 >
0851     struct In
0852     {
0853         typedef Size_<Arg1> type;
0854     };
0855 };
0856 Size_Helper const size_;
0857
0858 template <class Container>
0859 struct Max_Size_ : euml_action<Max_Size_<Container> >
0860 {
0861     template <class Event,class FSM,class STATE >
0862     struct state_action_result
0863     {
0864         typedef typename get_size_type<
0865             typename ::boost::remove_reference<
0866                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
0867     };
0868     template <class EVT,class FSM,class SourceState,class TargetState>
0869     struct transition_action_result
0870     {
0871         typedef typename get_size_type<
0872             typename ::boost::remove_reference<
0873                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
0874     };
0875     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0876
0877     template <class EVT,class FSM,class SourceState,class TargetState>
0878     typename ::boost::enable_if<
0879         typename ::boost::mpl::has_key<
0880             typename Container::tag_type,action_tag>::type,
0881             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
0882      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0883     {
0884         return (Container()(evt,fsm,src,tgt)).max_size();
0885     }
0886     template <class Event,class FSM,class STATE>
0887     typename ::boost::enable_if<
0888         typename ::boost::mpl::has_key<
0889             typename Container::tag_type,state_action_tag>::type,
0890             typename state_action_result<Event,FSM,STATE>::type >::type
0891      operator()(Event const& evt,FSM& fsm,STATE& state )const
0892     {
0893         return (Container()(evt,fsm,state)).max_size();
0894     }
0895 };
0896 struct max_size_tag {};
0897 struct Max_Size_Helper: proto::extends< proto::terminal<max_size_tag>::type, Max_Size_Helper, boost::msm::sm_domain>
0898 {
0899     Max_Size_Helper(){}
0900     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0901 #ifdef BOOST_MSVC
0902  ,class Arg6
0903 #endif
0904 >
0905     struct In
0906     {
0907         typedef Max_Size_<Arg1> type;
0908     };
0909 };
0910 Max_Size_Helper const max_size_;
0911
0912 template <class Container, class Value>
0913 struct Reserve_ : euml_action<Reserve_<Container,Value> >
0914 {
0915     template <class Event,class FSM,class STATE >
0916     struct state_action_result
0917     {
0918         typedef void type;
0919     };
0920     template <class EVT,class FSM,class SourceState,class TargetState>
0921     struct transition_action_result
0922     {
0923         typedef void type;
0924     };
0925     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0926
0927     template <class EVT,class FSM,class SourceState,class TargetState>
0928     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0929     {
0930         (Container()(evt,fsm,src,tgt)).reserve(Value()(evt,fsm,src,tgt));
0931     }
0932     template <class Event,class FSM,class STATE>
0933     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0934     {
0935         (Container()(evt,fsm,state)).reserve(Value()(evt,fsm,state));
0936     }
0937 };
0938 struct reserve_tag {};
0939 struct Reserve_Helper: proto::extends< proto::terminal<reserve_tag>::type, Reserve_Helper, boost::msm::sm_domain>
0940 {
0941     Reserve_Helper(){}
0942     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
0943 #ifdef BOOST_MSVC
0944  ,class Arg6
0945 #endif
0946 >
0947     struct In
0948     {
0949         typedef Reserve_<Arg1,Arg2> type;
0950     };
0951 };
0952 Reserve_Helper const reserve_;
0953
0954 template <class Container, class Num, class Value ,class Enable=void >
0955 struct Resize_ : euml_action<Resize_<Container,Num,Value> >
0956 {
0957     template <class Event,class FSM,class STATE >
0958     struct state_action_result
0959     {
0960         typedef void type;
0961     };
0962     template <class EVT,class FSM,class SourceState,class TargetState>
0963     struct transition_action_result
0964     {
0965         typedef void type;
0966     };
0967     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0968
0969     template <class EVT,class FSM,class SourceState,class TargetState>
0970     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0971     {
0972         (Container()(evt,fsm,src,tgt)).resize(Num()(evt,fsm,src,tgt));
0973     }
0974     template <class Event,class FSM,class STATE>
0975     void operator()(Event const& evt,FSM& fsm,STATE& state )const
0976     {
0977         (Container()(evt,fsm,state)).resize(Num()(evt,fsm,state));
0978     }
0979 };
0980 template <class Container, class Num , class Value >
0981 struct Resize_<Container,Num,Value,typename ::boost::disable_if<typename ::boost::is_same<Value,void>::type >::type>
0982                     : euml_action<Resize_<Container,Num,Value> >
0983 {
0984     template <class Event,class FSM,class STATE >
0985     struct state_action_result
0986     {
0987         typedef void type;
0988     };
0989     template <class EVT,class FSM,class SourceState,class TargetState>
0990     struct transition_action_result
0991     {
0992         typedef void type;
0993     };
0994     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
0995
0996     template <class EVT,class FSM,class SourceState,class TargetState>
0997     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
0998     {
0999         (Container()(evt,fsm,src,tgt)).resize(Num()(evt,fsm,src,tgt),Value()(evt,fsm,src,tgt));
1000     }
1001     template <class Event,class FSM,class STATE>
1002     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1003     {
1004         (Container()(evt,fsm,state)).resize(Num()(evt,fsm,state),Value()(evt,fsm,state));
1005     }
1006 };
1007 struct resize_tag {};
1008 struct Resize_Helper: proto::extends< proto::terminal<resize_tag>::type, Resize_Helper, boost::msm::sm_domain>
1009 {
1010     Resize_Helper(){}
1011     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1012 #ifdef BOOST_MSVC
1013  ,class Arg6
1014 #endif
1015 >
1016     struct In
1017     {
1018         typedef Resize_<Arg1,Arg2,Arg3> type;
1019     };
1020 };
1021 Resize_Helper const resize_;
1022
1023 // version for 3 parameters (sequence containers)
1024 template <class Container, class Param1, class Param2, class Param3 >
1025 struct Insert_ : euml_action<Insert_<Container,Param1,Param2,Param3> >
1026 {
1027     template <class Event,class FSM,class STATE >
1028     struct state_action_result
1029     {
1030         typedef void type;
1031     };
1032     template <class EVT,class FSM,class SourceState,class TargetState>
1033     struct transition_action_result
1034     {
1035         typedef void type;
1036     };
1037     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1038
1039     template <class EVT,class FSM,class SourceState,class TargetState>
1040     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1041     {
1042         (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
1043                                               Param3()(evt,fsm,src,tgt));
1044     }
1045     template <class Event,class FSM,class STATE>
1046     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1047     {
1048         (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1049                                             Param3()(evt,fsm,state));
1050     }
1051 };
1052 // version for 2 parameters
1053 template <class Container, class Param1, class Param2>
1054 struct Insert_ < Container,Param1,Param2,void>
1055     : euml_action<Insert_<Container,Param1,Param2,void> >
1056 {
1057     // return value will actually not be correct for set::insert(it1,it2), should be void
1058     // but it's ok as nobody should call an inexistent return type
1059     template <class Event,class FSM,class STATE >
1060     struct state_action_result
1061     {
1062         typedef typename get_iterator<
1063             typename ::boost::remove_reference<
1064                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
1065     };
1066     template <class EVT,class FSM,class SourceState,class TargetState>
1067     struct transition_action_result
1068     {
1069         typedef typename get_iterator<
1070             typename ::boost::remove_reference<
1071                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
1072     };
1073     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1074
1075     // version for transition + second param not an iterator (meaning that, Container is not an associative container)
1076     template <class EVT,class FSM,class SourceState,class TargetState>
1077     typename ::boost::enable_if<
1078         typename ::boost::mpl::and_<
1079             typename ::boost::mpl::has_key<
1080                 typename Container::tag_type,action_tag>::type,
1081                 typename ::boost::mpl::not_<
1082                     typename has_iterator_category<
1083                         typename Param2::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
1084                     >::type
1085                    >::type
1086                 >::type,
1087             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1088         >::type
1089      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1090     {
1091         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1092     }
1093
1094     // version for transition + second param is an iterator (meaning that, Container is an associative container)
1095     template <class EVT,class FSM,class SourceState,class TargetState>
1096     typename ::boost::enable_if<
1097         typename ::boost::mpl::and_<
1098             typename ::boost::mpl::has_key<
1099                 typename Container::tag_type,action_tag>::type,
1100                     typename has_iterator_category<
1101                         typename Param2::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
1102                     >::type
1103                 >::type,
1104             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1105         >::type
1106      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1107     {
1108         (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1109     }
1110
1111     // version for state action + second param not an iterator (meaning that, Container is not an associative container)
1112     template <class Event,class FSM,class STATE>
1113     typename ::boost::enable_if<
1114         typename ::boost::mpl::and_<
1115             typename ::boost::mpl::has_key<
1116                 typename Container::tag_type,state_action_tag>::type,
1117                 typename ::boost::mpl::not_<
1118                     typename has_iterator_category<
1119                         typename Param2::template state_action_result<Event,FSM,STATE>::type
1120                     >::type
1121                    >::type
1122                 >::type,
1123             typename state_action_result<Event,FSM,STATE>::type
1124         >::type
1125      operator()(Event const& evt,FSM& fsm,STATE& state )const
1126     {
1127         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1128     }
1129
1130     // version for state action + second param is an iterator (meaning that, Container is an associative container)
1131     template <class Event,class FSM,class STATE>
1132     typename ::boost::enable_if<
1133         typename ::boost::mpl::and_<
1134             typename ::boost::mpl::has_key<
1135                 typename Container::tag_type,state_action_tag>::type,
1136                     typename has_iterator_category<
1137                         typename Param2::template state_action_result<Event,FSM,STATE>::type
1138                     >::type
1139                 >::type,
1140             typename state_action_result<Event,FSM,STATE>::type
1141         >::type
1142      operator()(Event const& evt,FSM& fsm,STATE& state )const
1143     {
1144         (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1145     }
1146 };
1147
1148 // version for 1 parameter (associative containers)
1149 template <class Container, class Param1>
1150 struct Insert_ < Container,Param1,void,void>
1151     : euml_action<Insert_<Container,Param1,void,void> >
1152 {
1153     template <class Event,class FSM,class STATE >
1154     struct state_action_result
1155     {
1156         typedef typename std::pair<
1157             typename get_iterator<
1158                 typename ::boost::remove_reference<
1159                     typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type,bool> type;
1160     };
1161     template <class EVT,class FSM,class SourceState,class TargetState>
1162     struct transition_action_result
1163     {
1164         typedef typename std::pair<
1165             typename get_iterator<
1166                 typename ::boost::remove_reference<
1167                     typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type,bool> type;
1168     };
1169     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1170
1171     template <class EVT,class FSM,class SourceState,class TargetState>
1172     typename ::boost::enable_if<
1173         typename ::boost::mpl::has_key<
1174             typename Container::tag_type,action_tag>::type,
1175             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
1176      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1177     {
1178         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt));
1179     }
1180     template <class Event,class FSM,class STATE>
1181     typename ::boost::enable_if<
1182         typename ::boost::mpl::has_key<
1183             typename Container::tag_type,state_action_tag>::type,
1184             typename state_action_result<Event,FSM,STATE>::type >::type
1185      operator()(Event const& evt,FSM& fsm,STATE& state )const
1186     {
1187         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state));
1188     }
1189 };
1190 struct insert_tag {};
1191 struct Insert_Helper: proto::extends< proto::terminal<insert_tag>::type, Insert_Helper, boost::msm::sm_domain>
1192 {
1193     Insert_Helper(){}
1194     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1195 #ifdef BOOST_MSVC
1196  ,class Arg6
1197 #endif
1198 >
1199     struct In
1200     {
1201         typedef Insert_<Arg1,Arg2,Arg3,Arg4> type;
1202     };
1203 };
1204 Insert_Helper const insert_;
1205
1206 template <class Container1,class Container2>
1207 struct Swap_ : euml_action<Swap_<Container1,Container2> >
1208 {
1209     template <class Event,class FSM,class STATE >
1210     struct state_action_result
1211     {
1212         typedef void type;
1213     };
1214     template <class EVT,class FSM,class SourceState,class TargetState>
1215     struct transition_action_result
1216     {
1217         typedef void type;
1218     };
1219     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1220
1221     template <class EVT,class FSM,class SourceState,class TargetState>
1222     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1223     {
1224         (Container1()(evt,fsm,src,tgt)).swap(Container2()(evt,fsm,src,tgt));
1225     }
1226     template <class Event,class FSM,class STATE>
1227     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1228     {
1229         (Container1()(evt,fsm,state)).swap(Container2()(evt,fsm,state));
1230     }
1231 };
1232 struct swap_tag {};
1233 struct Swap_Helper: proto::extends< proto::terminal<swap_tag>::type, Swap_Helper, boost::msm::sm_domain>
1234 {
1235     Swap_Helper(){}
1236     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1237 #ifdef BOOST_MSVC
1238  ,class Arg6
1239 #endif
1240 >
1241     struct In
1242     {
1243         typedef Swap_<Arg1,Arg2> type;
1244     };
1245 };
1246 Swap_Helper const swap_;
1247
1248 template <class Container, class Iterator1, class Iterator2 ,class Enable=void >
1249 struct Erase_ : euml_action<Erase_<Container,Iterator1,Iterator2> >
1250 {
1251     template <class Event,class FSM,class STATE >
1252     struct state_action_result
1253     {
1254         typedef typename get_result_type2<Iterator1,Event,FSM,STATE>::type type;
1255     };
1256     template <class EVT,class FSM,class SourceState,class TargetState>
1257     struct transition_action_result
1258     {
1259         typedef typename get_result_type<Iterator1,EVT,FSM,SourceState,TargetState>::type type;
1260     };
1261     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1262
1263     template <class EVT,class FSM,class SourceState,class TargetState>
1264     typename ::boost::enable_if<
1265         typename ::boost::mpl::has_key<
1266             typename Iterator1::tag_type,action_tag>::type,
1267             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
1268     operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1269     {
1270         return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt));
1271     }
1272     template <class Event,class FSM,class STATE>
1273     typename ::boost::enable_if<
1274         typename ::boost::mpl::has_key<
1275             typename Iterator1::tag_type,state_action_tag>::type,
1276             typename state_action_result<Event,FSM,STATE>::type >::type
1277     operator()(Event const& evt,FSM& fsm,STATE& state )const
1278     {
1279         return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state));
1280     }
1281 };
1282 template <class Container, class Iterator1 , class Iterator2 >
1283 struct Erase_<Container,Iterator1,Iterator2,
1284               typename ::boost::disable_if<typename ::boost::is_same<Iterator2,void>::type >::type>
1285                     : euml_action<Erase_<Container,Iterator1,Iterator2> >
1286 {
1287     template <class Event,class FSM,class STATE >
1288     struct state_action_result
1289     {
1290         typedef typename get_result_type2<Iterator1,Event,FSM,STATE>::type type;
1291     };
1292     template <class EVT,class FSM,class SourceState,class TargetState>
1293     struct transition_action_result
1294     {
1295         typedef typename get_result_type<Iterator1,EVT,FSM,SourceState,TargetState>::type type;
1296     };
1297     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1298
1299     template <class EVT,class FSM,class SourceState,class TargetState>
1300     typename ::boost::enable_if<
1301         typename ::boost::mpl::has_key<
1302             typename Iterator1::tag_type,action_tag>::type,
1303             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
1304     operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1305     {
1306         return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt),Iterator2()(evt,fsm,src,tgt));
1307     }
1308     template <class Event,class FSM,class STATE>
1309     typename ::boost::enable_if<
1310         typename ::boost::mpl::has_key<
1311             typename Iterator1::tag_type,state_action_tag>::type,
1312             typename state_action_result<Event,FSM,STATE>::type >::type
1313     operator()(Event const& evt,FSM& fsm,STATE& state )const
1314     {
1315         return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state),Iterator2()(evt,fsm,state));
1316     }
1317 };
1318 struct erase_tag {};
1319 struct Erase_Helper: proto::extends< proto::terminal<erase_tag>::type, Erase_Helper, boost::msm::sm_domain>
1320 {
1321     Erase_Helper(){}
1322     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1323 #ifdef BOOST_MSVC
1324  ,class Arg6
1325 #endif
1326 >
1327     struct In
1328     {
1329         typedef Erase_<Arg1,Arg2,Arg3> type;
1330     };
1331 };
1332 Erase_Helper const erase_;
1333
1334 template <class Container>
1335 struct Empty_ : euml_action<Empty_<Container> >
1336 {
1337     template <class Event,class FSM,class STATE >
1338     struct state_action_result
1339     {
1340         typedef bool type;
1341     };
1342     template <class EVT,class FSM,class SourceState,class TargetState>
1343     struct transition_action_result
1344     {
1345         typedef bool type;
1346     };
1347     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1348
1349     template <class EVT,class FSM,class SourceState,class TargetState>
1350     bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1351     {
1352         return (Container()(evt,fsm,src,tgt)).empty();
1353     }
1354     template <class Event,class FSM,class STATE>
1355     bool operator()(Event const& evt,FSM& fsm,STATE& state )const
1356     {
1357         return (Container()(evt,fsm,state)).empty();
1358     }
1359 };
1360 struct empty_tag {};
1361 struct Empty_Helper: proto::extends< proto::terminal<empty_tag>::type, Empty_Helper, boost::msm::sm_domain>
1362 {
1363     Empty_Helper(){}
1364     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1365 #ifdef BOOST_MSVC
1366  ,class Arg6
1367 #endif
1368 >
1369     struct In
1370     {
1371         typedef Empty_<Arg1> type;
1372     };
1373 };
1374 Empty_Helper const empty_;
1375
1376 template <class Container,class Element>
1377 struct ListRemove_ : euml_action<ListRemove_<Container,Element> >
1378 {
1379     template <class Event,class FSM,class STATE >
1380     struct state_action_result
1381     {
1382         typedef void type;
1383     };
1384     template <class EVT,class FSM,class SourceState,class TargetState>
1385     struct transition_action_result
1386     {
1387         typedef void type;
1388     };
1389     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1390
1391     template <class EVT,class FSM,class SourceState,class TargetState>
1392     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1393     {
1394         (Container()(evt,fsm,src,tgt)).remove(Element()(evt,fsm,src,tgt));
1395     }
1396     template <class Event,class FSM,class STATE>
1397     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1398     {
1399         (Container()(evt,fsm,state)).remove(Element()(evt,fsm,state));
1400     }
1401 };
1402 struct list_remove_tag {};
1403 struct ListRemove_Helper: proto::extends< proto::terminal<list_remove_tag>::type, ListRemove_Helper, boost::msm::sm_domain>
1404 {
1405     ListRemove_Helper(){}
1406     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1407 #ifdef BOOST_MSVC
1408  ,class Arg6
1409 #endif
1410 >
1411     struct In
1412     {
1413         typedef ListRemove_<Arg1,Arg2> type;
1414     };
1415 };
1416 ListRemove_Helper const list_remove_;
1417
1418 template <class Container,class Element>
1419 struct ListRemove_If_ : euml_action<ListRemove_If_<Container,Element> >
1420 {
1421     template <class Event,class FSM,class STATE >
1422     struct state_action_result
1423     {
1424         typedef void type;
1425     };
1426     template <class EVT,class FSM,class SourceState,class TargetState>
1427     struct transition_action_result
1428     {
1429         typedef void type;
1430     };
1431     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1432
1433     template <class EVT,class FSM,class SourceState,class TargetState>
1434     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1435     {
1436         (Container()(evt,fsm,src,tgt)).remove_if(Element()(evt,fsm,src,tgt));
1437     }
1438     template <class Event,class FSM,class STATE>
1439     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1440     {
1441         (Container()(evt,fsm,state)).remove_if(Element()(evt,fsm,state));
1442     }
1443 };
1444 struct list_remove_if_tag {};
1445 struct ListRemove_If_Helper: proto::extends< proto::terminal<list_remove_if_tag>::type, ListRemove_If_Helper, boost::msm::sm_domain>
1446 {
1447     ListRemove_If_Helper(){}
1448     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1449 #ifdef BOOST_MSVC
1450  ,class Arg6
1451 #endif
1452 >
1453     struct In
1454     {
1455         typedef ListRemove_If_<Arg1,Arg2> type;
1456     };
1457 };
1458 ListRemove_If_Helper const list_remove_if_;
1459
1460 template <class Container, class ToMerge, class Predicate, class Enable=void>
1461 struct ListMerge_ : euml_action<ListMerge_<Container,ToMerge,Predicate,Enable> >
1462 {
1463     template <class Event,class FSM,class STATE >
1464     struct state_action_result
1465     {
1466         typedef void type;
1467     };
1468     template <class EVT,class FSM,class SourceState,class TargetState>
1469     struct transition_action_result
1470     {
1471         typedef void type;
1472     };
1473     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1474
1475     template <class EVT,class FSM,class SourceState,class TargetState>
1476     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1477     {
1478         (Container()(evt,fsm,src,tgt)).merge(ToMerge()(evt,fsm,src,tgt));
1479     }
1480     template <class Event,class FSM,class STATE>
1481     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1482     {
1483         (Container()(evt,fsm,state)).merge(ToMerge()(evt,fsm,state));
1484     }
1485 };
1486 template <class Container, class ToMerge, class Predicate >
1487 struct ListMerge_<Container,ToMerge,Predicate,
1488                typename ::boost::disable_if<typename ::boost::is_same<Predicate,void>::type >::type>
1489                     : euml_action<ListMerge_<Container,ToMerge,Predicate> >
1490 {
1491     template <class Event,class FSM,class STATE >
1492     struct state_action_result
1493     {
1494         typedef void type;
1495     };
1496     template <class EVT,class FSM,class SourceState,class TargetState>
1497     struct transition_action_result
1498     {
1499         typedef void type;
1500     };
1501     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1502
1503     template <class EVT,class FSM,class SourceState,class TargetState>
1504     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1505     {
1506         (Container()(evt,fsm,src,tgt)).merge(ToMerge()(evt,fsm,src,tgt),Predicate()(evt,fsm,src,tgt));
1507     }
1508     template <class Event,class FSM,class STATE>
1509     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1510     {
1511         (Container()(evt,fsm,state)).merge(ToMerge()(evt,fsm,state),Predicate()(evt,fsm,state));
1512     }
1513 };
1514 struct list_merge_tag {};
1515 struct ListMerge_Helper: proto::extends< proto::terminal<list_merge_tag>::type, ListMerge_Helper, boost::msm::sm_domain>
1516 {
1517     ListMerge_Helper(){}
1518     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1519 #ifdef BOOST_MSVC
1520  ,class Arg6
1521 #endif
1522 >
1523     struct In
1524     {
1525         typedef ListMerge_<Arg1,Arg2,Arg3> type;
1526     };
1527 };
1528 ListMerge_Helper const list_merge_;
1529
1530 template <class Container, class Param1, class Param2, class Param3, class Param4 ,class Enable=void >
1531 struct Splice_ : euml_action<Splice_<Container,Param1,Param2,Param3,Param4,Enable> >
1532 {
1533     template <class Event,class FSM,class STATE >
1534     struct state_action_result
1535     {
1536         typedef void type;
1537     };
1538     template <class EVT,class FSM,class SourceState,class TargetState>
1539     struct transition_action_result
1540     {
1541         typedef void type;
1542     };
1543     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1544
1545     template <class EVT,class FSM,class SourceState,class TargetState>
1546     typename ::boost::enable_if<
1547         typename ::boost::mpl::has_key<
1548             typename Container::tag_type,action_tag>::type,
1549             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
1550      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1551     {
1552         return (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1553     }
1554     template <class Event,class FSM,class STATE>
1555     typename ::boost::enable_if<
1556         typename ::boost::mpl::has_key<
1557             typename Container::tag_type,state_action_tag>::type,
1558             typename state_action_result<Event,FSM,STATE>::type >::type
1559      operator()(Event const& evt,FSM& fsm,STATE& state )const
1560     {
1561         return (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1562     }
1563 };
1564 template <class Container, class Param1, class Param2, class Param3, class Param4 >
1565 struct Splice_<Container,Param1,Param2,Param3,Param4,
1566                typename ::boost::disable_if<
1567                     typename ::boost::mpl::or_<typename ::boost::is_same<Param3,void>::type,
1568                                                typename ::boost::mpl::not_<
1569                                                     typename ::boost::is_same<Param4,void>::type>::type>::type >::type>
1570                     : euml_action<Splice_<Container,Param1,Param2,Param3,Param4> >
1571 {
1572     template <class Event,class FSM,class STATE >
1573     struct state_action_result
1574     {
1575         typedef void type;
1576     };
1577     template <class EVT,class FSM,class SourceState,class TargetState>
1578     struct transition_action_result
1579     {
1580         typedef void type;
1581     };
1582     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1583
1584     template <class EVT,class FSM,class SourceState,class TargetState>
1585     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1586     {
1587         (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
1588                                               Param3()(evt,fsm,src,tgt));
1589     }
1590     template <class Event,class FSM,class STATE>
1591     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1592     {
1593         (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1594                                             Param3()(evt,fsm,state));
1595     }
1596 };
1597 template <class Container, class Param1, class Param2, class Param3, class Param4 >
1598 struct Splice_<Container,Param1,Param2,Param3,Param4,
1599                typename ::boost::disable_if<typename ::boost::is_same<Param4,void>::type >::type>
1600                     : euml_action<Splice_<Container,Param1,Param2,Param3,Param4> >
1601 {
1602     template <class Event,class FSM,class STATE >
1603     struct state_action_result
1604     {
1605         typedef void type;
1606     };
1607     template <class EVT,class FSM,class SourceState,class TargetState>
1608     struct transition_action_result
1609     {
1610         typedef void type;
1611     };
1612     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1613
1614     template <class EVT,class FSM,class SourceState,class TargetState>
1615     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1616     {
1617         (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
1618                                               Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
1619     }
1620     template <class Event,class FSM,class STATE>
1621     void operator()(Event const& evt,FSM& fsm,STATE& state )const
1622     {
1623         (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1624                                             Param3()(evt,fsm,state),Param4()(evt,fsm,state));
1625     }
1626 };
1627 struct splice_tag {};
1628 struct Splice_Helper: proto::extends< proto::terminal<splice_tag>::type, Splice_Helper, boost::msm::sm_domain>
1629 {
1630     Splice_Helper(){}
1631     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1632 #ifdef BOOST_MSVC
1633  ,class Arg6
1634 #endif
1635 >
1636     struct In
1637     {
1638         typedef Splice_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
1639     };
1640 };
1641 Splice_Helper const splice_;
1642
1643 //template <class Container, class Param1, class Param2, class Param3, class Enable=void >
1644 //struct StringFind_ : euml_action<StringFind_<Container,Param1,Param2,Param3,Enable> >
1645 //{
1646 //};
1647 template <class Container,class Param1, class Param2, class Param3>
1648 struct StringFind_ : euml_action<StringFind_<Container,Param1,Param2,Param3> >
1649 {
1650     template <class Event,class FSM,class STATE >
1651     struct state_action_result
1652     {
1653         typedef typename remove_reference<
1654             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1655     };
1656     template <class EVT,class FSM,class SourceState,class TargetState>
1657     struct transition_action_result
1658     {
1659         typedef typename remove_reference<
1660             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1661     };
1662     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1663
1664     template <class EVT,class FSM,class SourceState,class TargetState>
1665     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1666        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1667     {
1668         return (Container()(evt,fsm,src,tgt)).
1669             find(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
1670     }
1671     template <class Event,class FSM,class STATE>
1672     typename state_action_result<Event,FSM,STATE>::type
1673         operator()(Event const& evt,FSM& fsm,STATE& state )const
1674     {
1675         return (Container()(evt,fsm,state)).
1676             find(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1677     }
1678 };
1679
1680 template <class Container,class Param1>
1681 struct StringFind_ < Container,Param1,void,void>
1682                 : euml_action<StringFind_<Container,Param1,void,void> >
1683
1684 {
1685     template <class Event,class FSM,class STATE >
1686     struct state_action_result
1687     {
1688         typedef typename remove_reference<
1689             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1690     };
1691     template <class EVT,class FSM,class SourceState,class TargetState>
1692     struct transition_action_result
1693     {
1694         typedef typename remove_reference<
1695             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1696     };
1697     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1698
1699     template <class EVT,class FSM,class SourceState,class TargetState>
1700     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1701        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1702     {
1703         return (Container()(evt,fsm,src,tgt)).find(Param1()(evt,fsm,src,tgt));
1704     }
1705     template <class Event,class FSM,class STATE>
1706     typename state_action_result<Event,FSM,STATE>::type
1707         operator()(Event const& evt,FSM& fsm,STATE& state )const
1708     {
1709         return (Container()(evt,fsm,state)).find(Param1()(evt,fsm,state));
1710     }
1711 };
1712
1713 template <class Container,class Param1, class Param2>
1714 struct StringFind_ <Container,Param1,Param2,void>
1715                 : euml_action<StringFind_<Container,Param1,Param2,void> >
1716 {
1717     template <class Event,class FSM,class STATE >
1718     struct state_action_result
1719     {
1720         typedef typename remove_reference<
1721             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1722     };
1723     template <class EVT,class FSM,class SourceState,class TargetState>
1724     struct transition_action_result
1725     {
1726         typedef typename remove_reference<
1727             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1728     };
1729     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1730
1731     template <class EVT,class FSM,class SourceState,class TargetState>
1732     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1733        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1734     {
1735         return (Container()(evt,fsm,src,tgt)).find(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1736     }
1737     template <class Event,class FSM,class STATE>
1738     typename state_action_result<Event,FSM,STATE>::type
1739         operator()(Event const& evt,FSM& fsm,STATE& state )const
1740     {
1741         return (Container()(evt,fsm,state)).find(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1742     }
1743 };
1744
1745 struct string_find_tag {};
1746 struct StringFind_Helper: proto::extends< proto::terminal<string_find_tag>::type, StringFind_Helper, boost::msm::sm_domain>
1747 {
1748     StringFind_Helper(){}
1749     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1750 #ifdef BOOST_MSVC
1751  ,class Arg6
1752 #endif
1753 >
1754     struct In
1755     {
1756         typedef StringFind_<Arg1,Arg2,Arg3,Arg4> type;
1757     };
1758 };
1759 StringFind_Helper const string_find_;
1760
1761 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
1762 struct StringRFind_ : euml_action<StringRFind_<Container,Param1,Param2,Param3,Enable> >
1763 {
1764 };
1765
1766 template <class Container,class Param1, class Param2, class Param3>
1767 struct StringRFind_ <
1768         Container,Param1,Param2,Param3,
1769         typename ::boost::enable_if<
1770                     typename ::boost::is_same<Param2,void>::type
1771                     >::type
1772                 >
1773                 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1774
1775 {
1776     template <class Event,class FSM,class STATE >
1777     struct state_action_result
1778     {
1779         typedef typename remove_reference<
1780             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1781     };
1782     template <class EVT,class FSM,class SourceState,class TargetState>
1783     struct transition_action_result
1784     {
1785         typedef typename remove_reference<
1786             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1787     };
1788     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1789
1790     template <class EVT,class FSM,class SourceState,class TargetState>
1791     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1792        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1793     {
1794         return (Container()(evt,fsm,src,tgt)).rfind(Param1()(evt,fsm,src,tgt));
1795     }
1796     template <class Event,class FSM,class STATE>
1797     typename state_action_result<Event,FSM,STATE>::type
1798         operator()(Event const& evt,FSM& fsm,STATE& state )const
1799     {
1800         return (Container()(evt,fsm,state)).rfind(Param1()(evt,fsm,state));
1801     }
1802 };
1803
1804 template <class Container,class Param1, class Param2, class Param3>
1805 struct StringRFind_ <
1806                 Container,Param1,Param2,Param3,
1807                     typename ::boost::enable_if<
1808                         typename ::boost::mpl::and_<
1809                             typename ::boost::is_same<Param3,void>::type,
1810                             typename ::boost::mpl::not_<
1811                                 typename ::boost::is_same<Param2,void>::type
1812                                                 >::type
1813                                              >::type
1814                                        >::type
1815                     >
1816                 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1817 {
1818     template <class Event,class FSM,class STATE >
1819     struct state_action_result
1820     {
1821         typedef typename remove_reference<
1822             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1823     };
1824     template <class EVT,class FSM,class SourceState,class TargetState>
1825     struct transition_action_result
1826     {
1827         typedef typename remove_reference<
1828             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1829     };
1830     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1831
1832     template <class EVT,class FSM,class SourceState,class TargetState>
1833     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1834        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1835     {
1836         return (Container()(evt,fsm,src,tgt)).rfind(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1837     }
1838     template <class Event,class FSM,class STATE>
1839     typename state_action_result<Event,FSM,STATE>::type
1840         operator()(Event const& evt,FSM& fsm,STATE& state )const
1841     {
1842         return (Container()(evt,fsm,state)).rfind(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1843     }
1844 };
1845
1846 template <class Container,class Param1, class Param2, class Param3>
1847 struct StringRFind_<
1848     Container,Param1,Param2,Param3,
1849             typename ::boost::disable_if<
1850                                 typename ::boost::is_same<Param3,void>::type
1851                                 >::type
1852                 >
1853                 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1854 {
1855     template <class Event,class FSM,class STATE >
1856     struct state_action_result
1857     {
1858         typedef typename remove_reference<
1859             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1860     };
1861     template <class EVT,class FSM,class SourceState,class TargetState>
1862     struct transition_action_result
1863     {
1864         typedef typename remove_reference<
1865             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1866     };
1867     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1868
1869     template <class EVT,class FSM,class SourceState,class TargetState>
1870     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1871        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1872     {
1873         return (Container()(evt,fsm,src,tgt)).
1874             rfind(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
1875     }
1876     template <class Event,class FSM,class STATE>
1877     typename state_action_result<Event,FSM,STATE>::type
1878         operator()(Event const& evt,FSM& fsm,STATE& state )const
1879     {
1880         return (Container()(evt,fsm,state)).
1881             rfind(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1882     }
1883 };
1884
1885 struct string_rfind_tag {};
1886 struct StringRFind_Helper: proto::extends< proto::terminal<string_rfind_tag>::type, StringRFind_Helper, boost::msm::sm_domain>
1887 {
1888     StringRFind_Helper(){}
1889     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1890 #ifdef BOOST_MSVC
1891  ,class Arg6
1892 #endif
1893 >
1894     struct In
1895     {
1896         typedef StringRFind_<Arg1,Arg2,Arg3,Arg4> type;
1897     };
1898 };
1899 StringRFind_Helper const string_rfind_;
1900
1901 template <class Container,class Param1, class Param2, class Param3>
1902 struct StringFindFirstOf_ : euml_action<StringFindFirstOf_<Container,Param1,Param2,Param3> >
1903 {
1904     template <class Event,class FSM,class STATE >
1905     struct state_action_result
1906     {
1907         typedef typename remove_reference<
1908             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1909     };
1910     template <class EVT,class FSM,class SourceState,class TargetState>
1911     struct transition_action_result
1912     {
1913         typedef typename remove_reference<
1914             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1915     };
1916     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1917
1918     template <class EVT,class FSM,class SourceState,class TargetState>
1919     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1920        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1921     {
1922         return (Container()(evt,fsm,src,tgt)).
1923             find_first_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
1924     }
1925     template <class Event,class FSM,class STATE>
1926     typename state_action_result<Event,FSM,STATE>::type
1927         operator()(Event const& evt,FSM& fsm,STATE& state )const
1928     {
1929         return (Container()(evt,fsm,state)).
1930             find_first_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1931     }
1932 };
1933 template <class Container,class Param1>
1934 struct StringFindFirstOf_ <Container,Param1,void,void>
1935                 : euml_action<StringFindFirstOf_<Container,Param1,void,void> >
1936 {
1937     template <class Event,class FSM,class STATE >
1938     struct state_action_result
1939     {
1940         typedef typename remove_reference<
1941             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1942     };
1943     template <class EVT,class FSM,class SourceState,class TargetState>
1944     struct transition_action_result
1945     {
1946         typedef typename remove_reference<
1947             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1948     };
1949     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1950
1951     template <class EVT,class FSM,class SourceState,class TargetState>
1952     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1953        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1954     {
1955         return (Container()(evt,fsm,src,tgt)).find_first_of(Param1()(evt,fsm,src,tgt));
1956     }
1957     template <class Event,class FSM,class STATE>
1958     typename state_action_result<Event,FSM,STATE>::type
1959         operator()(Event const& evt,FSM& fsm,STATE& state )const
1960     {
1961         return (Container()(evt,fsm,state)).find_first_of(Param1()(evt,fsm,state));
1962     }
1963 };
1964
1965 template <class Container,class Param1, class Param2>
1966 struct StringFindFirstOf_ <Container,Param1,Param2,void>
1967                 : euml_action<StringFindFirstOf_<Container,Param1,Param2,void> >
1968 {
1969     template <class Event,class FSM,class STATE >
1970     struct state_action_result
1971     {
1972         typedef typename remove_reference<
1973             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1974     };
1975     template <class EVT,class FSM,class SourceState,class TargetState>
1976     struct transition_action_result
1977     {
1978         typedef typename remove_reference<
1979             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1980     };
1981     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
1982
1983     template <class EVT,class FSM,class SourceState,class TargetState>
1984     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1985        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1986     {
1987         return (Container()(evt,fsm,src,tgt)).find_first_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1988     }
1989     template <class Event,class FSM,class STATE>
1990     typename state_action_result<Event,FSM,STATE>::type
1991         operator()(Event const& evt,FSM& fsm,STATE& state )const
1992     {
1993         return (Container()(evt,fsm,state)).find_first_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1994     }
1995 };
1996
1997 struct string_find_first_of_tag {};
1998 struct StringFindFirstOf_Helper:
1999     proto::extends< proto::terminal<string_find_first_of_tag>::type, StringFindFirstOf_Helper, boost::msm::sm_domain>
2000 {
2001     StringFindFirstOf_Helper(){}
2002     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2003 #ifdef BOOST_MSVC
2004  ,class Arg6
2005 #endif
2006 >
2007     struct In
2008     {
2009         typedef StringFindFirstOf_<Arg1,Arg2,Arg3,Arg4> type;
2010     };
2011 };
2012 StringFindFirstOf_Helper const string_find_first_of_;
2013
2014 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2015 struct StringFindFirstNotOf_ : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3,Enable> >
2016 {
2017 };
2018
2019 template <class Container,class Param1, class Param2, class Param3>
2020 struct StringFindFirstNotOf_ <
2021         Container,Param1,Param2,Param3,
2022         typename ::boost::enable_if<
2023                     typename ::boost::is_same<Param2,void>::type
2024                     >::type
2025                 >
2026                 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2027
2028 {
2029     template <class Event,class FSM,class STATE >
2030     struct state_action_result
2031     {
2032         typedef typename remove_reference<
2033             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2034     };
2035     template <class EVT,class FSM,class SourceState,class TargetState>
2036     struct transition_action_result
2037     {
2038         typedef typename remove_reference<
2039             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2040     };
2041     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2042
2043     template <class EVT,class FSM,class SourceState,class TargetState>
2044     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2045        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2046     {
2047         return (Container()(evt,fsm,src,tgt)).find_first_not_of(Param1()(evt,fsm,src,tgt));
2048     }
2049     template <class Event,class FSM,class STATE>
2050     typename state_action_result<Event,FSM,STATE>::type
2051         operator()(Event const& evt,FSM& fsm,STATE& state )const
2052     {
2053         return (Container()(evt,fsm,state)).find_first_not_of(Param1()(evt,fsm,state));
2054     }
2055 };
2056
2057 template <class Container,class Param1, class Param2, class Param3>
2058 struct StringFindFirstNotOf_ <
2059                 Container,Param1,Param2,Param3,
2060                     typename ::boost::enable_if<
2061                         typename ::boost::mpl::and_<
2062                             typename ::boost::is_same<Param3,void>::type,
2063                             typename ::boost::mpl::not_<
2064                                 typename ::boost::is_same<Param2,void>::type
2065                                                 >::type
2066                                              >::type
2067                                        >::type
2068                     >
2069                 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2070 {
2071     template <class Event,class FSM,class STATE >
2072     struct state_action_result
2073     {
2074         typedef typename remove_reference<
2075             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2076     };
2077     template <class EVT,class FSM,class SourceState,class TargetState>
2078     struct transition_action_result
2079     {
2080         typedef typename remove_reference<
2081             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2082     };
2083     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2084
2085     template <class EVT,class FSM,class SourceState,class TargetState>
2086     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2087        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2088     {
2089         return (Container()(evt,fsm,src,tgt)).find_first_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
2090     }
2091     template <class Event,class FSM,class STATE>
2092     typename state_action_result<Event,FSM,STATE>::type
2093         operator()(Event const& evt,FSM& fsm,STATE& state )const
2094     {
2095         return (Container()(evt,fsm,state)).find_first_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
2096     }
2097 };
2098
2099 template <class Container,class Param1, class Param2, class Param3>
2100 struct StringFindFirstNotOf_<
2101     Container,Param1,Param2,Param3,
2102             typename ::boost::disable_if<
2103                                 typename ::boost::is_same<Param3,void>::type
2104                                 >::type
2105                 >
2106                 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2107 {
2108     template <class Event,class FSM,class STATE >
2109     struct state_action_result
2110     {
2111         typedef typename remove_reference<
2112             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2113     };
2114     template <class EVT,class FSM,class SourceState,class TargetState>
2115     struct transition_action_result
2116     {
2117         typedef typename remove_reference<
2118             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2119     };
2120     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2121
2122     template <class EVT,class FSM,class SourceState,class TargetState>
2123     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2124        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2125     {
2126         return (Container()(evt,fsm,src,tgt)).
2127             find_first_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
2128     }
2129     template <class Event,class FSM,class STATE>
2130     typename state_action_result<Event,FSM,STATE>::type
2131         operator()(Event const& evt,FSM& fsm,STATE& state )const
2132     {
2133         return (Container()(evt,fsm,state)).
2134             find_first_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
2135     }
2136 };
2137
2138 struct string_find_first_not_of_tag {};
2139 struct StringFindFirstNotOf_Helper:
2140     proto::extends< proto::terminal<string_find_first_not_of_tag>::type, StringFindFirstNotOf_Helper, boost::msm::sm_domain>
2141 {
2142     StringFindFirstNotOf_Helper(){}
2143     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2144 #ifdef BOOST_MSVC
2145  ,class Arg6
2146 #endif
2147 >
2148     struct In
2149     {
2150         typedef StringFindFirstNotOf_<Arg1,Arg2,Arg3,Arg4> type;
2151     };
2152 };
2153 StringFindFirstNotOf_Helper const string_find_first_not_of_;
2154
2155 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2156 struct StringFindLastOf_ : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3,Enable> >
2157 {
2158 };
2159
2160 template <class Container,class Param1, class Param2, class Param3>
2161 struct StringFindLastOf_ <
2162         Container,Param1,Param2,Param3,
2163         typename ::boost::enable_if<
2164                     typename ::boost::is_same<Param2,void>::type
2165                     >::type
2166                 >
2167                 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2168
2169 {
2170     template <class Event,class FSM,class STATE >
2171     struct state_action_result
2172     {
2173         typedef typename remove_reference<
2174             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2175     };
2176     template <class EVT,class FSM,class SourceState,class TargetState>
2177     struct transition_action_result
2178     {
2179         typedef typename remove_reference<
2180             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2181     };
2182     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2183
2184     template <class EVT,class FSM,class SourceState,class TargetState>
2185     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2186        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2187     {
2188         return (Container()(evt,fsm,src,tgt)).find_last_of(Param1()(evt,fsm,src,tgt));
2189     }
2190     template <class Event,class FSM,class STATE>
2191     typename state_action_result<Event,FSM,STATE>::type
2192         operator()(Event const& evt,FSM& fsm,STATE& state )const
2193     {
2194         return (Container()(evt,fsm,state)).find_last_of(Param1()(evt,fsm,state));
2195     }
2196 };
2197
2198 template <class Container,class Param1, class Param2, class Param3>
2199 struct StringFindLastOf_ <
2200                 Container,Param1,Param2,Param3,
2201                     typename ::boost::enable_if<
2202                         typename ::boost::mpl::and_<
2203                             typename ::boost::is_same<Param3,void>::type,
2204                             typename ::boost::mpl::not_<
2205                                 typename ::boost::is_same<Param2,void>::type
2206                                                 >::type
2207                                              >::type
2208                                        >::type
2209                     >
2210                 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2211 {
2212     template <class Event,class FSM,class STATE >
2213     struct state_action_result
2214     {
2215         typedef typename remove_reference<
2216             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2217     };
2218     template <class EVT,class FSM,class SourceState,class TargetState>
2219     struct transition_action_result
2220     {
2221         typedef typename remove_reference<
2222             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2223     };
2224     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2225
2226     template <class EVT,class FSM,class SourceState,class TargetState>
2227     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2228        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2229     {
2230         return (Container()(evt,fsm,src,tgt)).find_last_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
2231     }
2232     template <class Event,class FSM,class STATE>
2233     typename state_action_result<Event,FSM,STATE>::type
2234         operator()(Event const& evt,FSM& fsm,STATE& state )const
2235     {
2236         return (Container()(evt,fsm,state)).find_last_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
2237     }
2238 };
2239
2240 template <class Container,class Param1, class Param2, class Param3>
2241 struct StringFindLastOf_<
2242     Container,Param1,Param2,Param3,
2243             typename ::boost::disable_if<
2244                                 typename ::boost::is_same<Param3,void>::type
2245                                 >::type
2246                 >
2247                 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2248 {
2249     template <class Event,class FSM,class STATE >
2250     struct state_action_result
2251     {
2252         typedef typename remove_reference<
2253             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2254     };
2255     template <class EVT,class FSM,class SourceState,class TargetState>
2256     struct transition_action_result
2257     {
2258         typedef typename remove_reference<
2259             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2260     };
2261     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2262
2263     template <class EVT,class FSM,class SourceState,class TargetState>
2264     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2265        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2266     {
2267         return (Container()(evt,fsm,src,tgt)).
2268             find_last_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
2269     }
2270     template <class Event,class FSM,class STATE>
2271     typename state_action_result<Event,FSM,STATE>::type
2272         operator()(Event const& evt,FSM& fsm,STATE& state )const
2273     {
2274         return (Container()(evt,fsm,state)).
2275             find_last_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
2276     }
2277 };
2278
2279 struct string_find_last_of_tag {};
2280 struct StringFindLastOf_Helper:
2281     proto::extends< proto::terminal<string_find_last_of_tag>::type, StringFindLastOf_Helper, boost::msm::sm_domain>
2282 {
2283     StringFindLastOf_Helper(){}
2284     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2285 #ifdef BOOST_MSVC
2286  ,class Arg6
2287 #endif
2288 >
2289     struct In
2290     {
2291         typedef StringFindLastOf_<Arg1,Arg2,Arg3,Arg4> type;
2292     };
2293 };
2294 StringFindLastOf_Helper const string_find_last_of_;
2295
2296 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2297 struct StringFindLastNotOf_ : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3,Enable> >
2298 {
2299 };
2300
2301 template <class Container,class Param1, class Param2, class Param3>
2302 struct StringFindLastNotOf_ <
2303         Container,Param1,Param2,Param3,
2304         typename ::boost::enable_if<
2305                     typename ::boost::is_same<Param2,void>::type
2306                     >::type
2307                 >
2308                 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2309
2310 {
2311     template <class Event,class FSM,class STATE >
2312     struct state_action_result
2313     {
2314         typedef typename remove_reference<
2315             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2316     };
2317     template <class EVT,class FSM,class SourceState,class TargetState>
2318     struct transition_action_result
2319     {
2320         typedef typename remove_reference<
2321             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2322     };
2323     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2324
2325     template <class EVT,class FSM,class SourceState,class TargetState>
2326     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2327        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2328     {
2329         return (Container()(evt,fsm,src,tgt)).find_last_not_of(Param1()(evt,fsm,src,tgt));
2330     }
2331     template <class Event,class FSM,class STATE>
2332     typename state_action_result<Event,FSM,STATE>::type
2333         operator()(Event const& evt,FSM& fsm,STATE& state )const
2334     {
2335         return (Container()(evt,fsm,state)).find_last_not_of(Param1()(evt,fsm,state));
2336     }
2337 };
2338
2339 template <class Container,class Param1, class Param2, class Param3>
2340 struct StringFindLastNotOf_ <
2341                 Container,Param1,Param2,Param3,
2342                     typename ::boost::enable_if<
2343                         typename ::boost::mpl::and_<
2344                             typename ::boost::is_same<Param3,void>::type,
2345                             typename ::boost::mpl::not_<
2346                                 typename ::boost::is_same<Param2,void>::type
2347                                                 >::type
2348                                              >::type
2349                                        >::type
2350                     >
2351                 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2352 {
2353     template <class Event,class FSM,class STATE >
2354     struct state_action_result
2355     {
2356         typedef typename remove_reference<
2357             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2358     };
2359     template <class EVT,class FSM,class SourceState,class TargetState>
2360     struct transition_action_result
2361     {
2362         typedef typename remove_reference<
2363             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2364     };
2365     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2366
2367     template <class EVT,class FSM,class SourceState,class TargetState>
2368     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2369        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2370     {
2371         return (Container()(evt,fsm,src,tgt)).find_last_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
2372     }
2373     template <class Event,class FSM,class STATE>
2374     typename state_action_result<Event,FSM,STATE>::type
2375         operator()(Event const& evt,FSM& fsm,STATE& state )const
2376     {
2377         return (Container()(evt,fsm,state)).find_last_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
2378     }
2379 };
2380
2381 template <class Container,class Param1, class Param2, class Param3>
2382 struct StringFindLastNotOf_<
2383     Container,Param1,Param2,Param3,
2384             typename ::boost::disable_if<
2385                                 typename ::boost::is_same<Param3,void>::type
2386                                 >::type
2387                 >
2388                 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2389 {
2390     template <class Event,class FSM,class STATE >
2391     struct state_action_result
2392     {
2393         typedef typename remove_reference<
2394             typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2395     };
2396     template <class EVT,class FSM,class SourceState,class TargetState>
2397     struct transition_action_result
2398     {
2399         typedef typename remove_reference<
2400             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2401     };
2402     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2403
2404     template <class EVT,class FSM,class SourceState,class TargetState>
2405     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2406        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2407     {
2408         return (Container()(evt,fsm,src,tgt)).
2409             find_last_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
2410     }
2411     template <class Event,class FSM,class STATE>
2412     typename state_action_result<Event,FSM,STATE>::type
2413         operator()(Event const& evt,FSM& fsm,STATE& state )const
2414     {
2415         return (Container()(evt,fsm,state)).
2416             find_last_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
2417     }
2418 };
2419
2420 struct string_find_last_not_of_tag {};
2421 struct StringFindLastNotOf_Helper:
2422     proto::extends< proto::terminal<string_find_last_of_tag>::type, StringFindLastNotOf_Helper, boost::msm::sm_domain>
2423 {
2424     StringFindLastNotOf_Helper(){}
2425     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2426 #ifdef BOOST_MSVC
2427  ,class Arg6
2428 #endif
2429 >
2430     struct In
2431     {
2432         typedef StringFindLastNotOf_<Arg1,Arg2,Arg3,Arg4> type;
2433     };
2434 };
2435 StringFindLastNotOf_Helper const string_find_last_not_of_;
2436
2437 template <class Container>
2438 struct Npos_ : euml_action<Npos_<Container> >
2439 {
2440     Npos_(){}
2441     template <class Event,class FSM,class STATE >
2442     struct state_action_result
2443     {
2444         typedef typename Container::size_type type;
2445     };
2446     template <class EVT,class FSM,class SourceState,class TargetState>
2447     struct transition_action_result
2448     {
2449         typedef typename Container::size_type type;
2450     };
2451     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2452
2453     template <class EVT,class FSM,class SourceState,class TargetState>
2454     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2455         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2456     {
2457         return Container::npos;
2458     }
2459     template <class Event,class FSM,class STATE>
2460     typename state_action_result<Event,FSM,STATE>::type
2461         operator()(Event const& evt,FSM& fsm,STATE& state )const
2462     {
2463         return Container::npos;
2464     }
2465 };
2466
2467 // version for 2 parameters
2468 template <class Container, class Param1, class Param2>
2469 struct Associative_Erase_ : euml_action<Associative_Erase_<Container,Param1,Param2> >
2470 {
2471     template <class Event,class FSM,class STATE >
2472     struct state_action_result
2473     {
2474         typedef void type;
2475     };
2476     template <class EVT,class FSM,class SourceState,class TargetState>
2477     struct transition_action_result
2478     {
2479         typedef void type;
2480     };
2481     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2482
2483     template <class EVT,class FSM,class SourceState,class TargetState>
2484     typename ::boost::enable_if<
2485         typename ::boost::mpl::has_key<
2486             typename Container::tag_type,action_tag>::type,
2487             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2488      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2489     {
2490         (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
2491     }
2492     template <class Event,class FSM,class STATE>
2493     typename ::boost::enable_if<
2494         typename ::boost::mpl::has_key<
2495             typename Container::tag_type,state_action_tag>::type,
2496             typename state_action_result<Event,FSM,STATE>::type >::type
2497      operator()(Event const& evt,FSM& fsm,STATE& state )const
2498     {
2499         (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
2500     }
2501 };
2502 // version for 1 parameter
2503 template <class Container, class Param1>
2504 struct Associative_Erase_ < Container,Param1,void>
2505     : euml_action<Associative_Erase_<Container,Param1,void> >
2506 {
2507     // return value will actually not be correct for set::erase(it), should be void
2508     // but it's ok as nobody should call an inexistent return type
2509     template <class Event,class FSM,class STATE >
2510     struct state_action_result
2511     {
2512         typedef typename get_size_type<
2513             typename ::boost::remove_reference<
2514                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
2515     };
2516     template <class EVT,class FSM,class SourceState,class TargetState>
2517     struct transition_action_result
2518     {
2519         typedef typename get_size_type<
2520             typename ::boost::remove_reference<
2521                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2522     };
2523     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2524
2525     // version for transition + param is an iterator
2526     template <class EVT,class FSM,class SourceState,class TargetState>
2527     typename ::boost::enable_if<
2528         typename ::boost::mpl::and_<
2529             typename ::boost::mpl::has_key<
2530                 typename Container::tag_type,action_tag>::type,
2531                     typename has_iterator_category<
2532                         typename Param1::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
2533                     >::type
2534                 >::type,
2535             void
2536         >::type
2537      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2538     {
2539         (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
2540     }
2541
2542     // version for state action + param is an iterator
2543     template <class Event,class FSM,class STATE>
2544     typename ::boost::enable_if<
2545         typename ::boost::mpl::and_<
2546             typename ::boost::mpl::has_key<
2547                 typename Container::tag_type,state_action_tag>::type,
2548                     typename has_iterator_category<
2549                         typename Param1::template state_action_result<Event,FSM,STATE>::type
2550                     >::type
2551                 >::type,
2552             void
2553         >::type
2554      operator()(Event const& evt,FSM& fsm,STATE& state )const
2555     {
2556         (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
2557     }
2558
2559     // version for transition + param not an iterator
2560     template <class EVT,class FSM,class SourceState,class TargetState>
2561     typename ::boost::enable_if<
2562         typename ::boost::mpl::and_<
2563             typename ::boost::mpl::has_key<
2564                 typename Container::tag_type,action_tag>::type,
2565                 typename ::boost::mpl::not_<
2566                     typename has_iterator_category<
2567                         typename Param1::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
2568                     >::type
2569                    >::type
2570                 >::type,
2571             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2572         >::type
2573      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2574     {
2575         return (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
2576     }
2577
2578     // version for state action + param not an iterator
2579     template <class Event,class FSM,class STATE>
2580     typename ::boost::enable_if<
2581         typename ::boost::mpl::and_<
2582             typename ::boost::mpl::has_key<
2583                 typename Container::tag_type,state_action_tag>::type,
2584                 typename ::boost::mpl::not_<
2585                     typename has_iterator_category<
2586                         typename Param1::template state_action_result<Event,FSM,STATE>::type
2587                     >::type
2588                    >::type
2589                 >::type,
2590             typename state_action_result<Event,FSM,STATE>::type
2591         >::type
2592      operator()(Event const& evt,FSM& fsm,STATE& state )const
2593     {
2594         return (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
2595     }
2596 };
2597
2598 struct associative_erase_tag {};
2599 struct Associative_Erase_Helper: proto::extends< proto::terminal<associative_erase_tag>::type, Associative_Erase_Helper, boost::msm::sm_domain>
2600 {
2601     Associative_Erase_Helper(){}
2602     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2603 #ifdef BOOST_MSVC
2604  ,class Arg6
2605 #endif
2606 >
2607     struct In
2608     {
2609         typedef Associative_Erase_<Arg1,Arg2,Arg3> type;
2610     };
2611 };
2612 Associative_Erase_Helper const associative_erase_;
2613
2614
2615 template <class T, class Param>
2616 struct Associative_Find_ : euml_action<Associative_Find_<T,Param> >
2617 {
2618     template <class Event,class FSM,class STATE >
2619     struct state_action_result
2620     {
2621         typedef typename get_iterator<
2622             typename ::boost::remove_reference<
2623                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2624     };
2625     template <class EVT,class FSM,class SourceState,class TargetState>
2626     struct transition_action_result
2627     {
2628         typedef typename get_iterator<
2629             typename ::boost::remove_reference<
2630                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2631     };
2632     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2633
2634     template <class EVT,class FSM,class SourceState,class TargetState>
2635     typename ::boost::enable_if<
2636         typename ::boost::mpl::has_key<
2637             typename T::tag_type,action_tag>::type,
2638             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2639         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2640     {
2641         return (T()(evt,fsm,src,tgt)).find(Param()(evt,fsm,src,tgt));
2642     }
2643     template <class Event,class FSM,class STATE>
2644     typename ::boost::enable_if<
2645         typename ::boost::mpl::has_key<
2646             typename T::tag_type,state_action_tag>::type,
2647             typename state_action_result<Event,FSM,STATE>::type >::type
2648         operator()(Event const& evt,FSM& fsm,STATE& state )const
2649     {
2650         return (T()(evt,fsm,state)).find(Param()(evt,fsm,state));
2651     }
2652 };
2653
2654 struct associative_find_tag {};
2655 struct Associative_Find_Helper: proto::extends< proto::terminal<associative_find_tag>::type, Associative_Find_Helper, boost::msm::sm_domain>
2656 {
2657     Associative_Find_Helper(){}
2658     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2659 #ifdef BOOST_MSVC
2660  ,class Arg6
2661 #endif
2662 >
2663     struct In
2664     {
2665         typedef Associative_Find_<Arg1,Arg2> type;
2666     };
2667 };
2668 Associative_Find_Helper const associative_find_;
2669
2670 template <class Container,class Param>
2671 struct AssociativeCount_ : euml_action<AssociativeCount_<Container,Param> >
2672 {
2673     template <class Event,class FSM,class STATE >
2674     struct state_action_result
2675     {
2676         typedef typename get_size_type<
2677             typename ::boost::remove_reference<
2678                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
2679     };
2680     template <class EVT,class FSM,class SourceState,class TargetState>
2681     struct transition_action_result
2682     {
2683         typedef typename get_size_type<
2684             typename ::boost::remove_reference<
2685                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2686     };
2687     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2688
2689     template <class EVT,class FSM,class SourceState,class TargetState>
2690     typename ::boost::enable_if<
2691         typename ::boost::mpl::has_key<
2692             typename Container::tag_type,action_tag>::type,
2693             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2694      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2695     {
2696         return (Container()(evt,fsm,src,tgt)).count(Param()(evt,fsm,src,tgt));
2697     }
2698     template <class Event,class FSM,class STATE>
2699     typename ::boost::enable_if<
2700         typename ::boost::mpl::has_key<
2701             typename Container::tag_type,state_action_tag>::type,
2702             typename state_action_result<Event,FSM,STATE>::type >::type
2703      operator()(Event const& evt,FSM& fsm,STATE& state )const
2704     {
2705         return (Container()(evt,fsm,state)).count(Param()(evt,fsm,state));
2706     }
2707 };
2708 struct associative_count_tag {};
2709 struct AssociativeCount_Helper: proto::extends< proto::terminal<associative_count_tag>::type, AssociativeCount_Helper, boost::msm::sm_domain>
2710 {
2711     AssociativeCount_Helper(){}
2712     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2713 #ifdef BOOST_MSVC
2714  ,class Arg6
2715 #endif
2716 >
2717     struct In
2718     {
2719         typedef AssociativeCount_<Arg1,Arg2> type;
2720     };
2721 };
2722 AssociativeCount_Helper const associative_count_;
2723
2724 template <class T, class Param>
2725 struct Associative_Lower_Bound_ : euml_action<Associative_Lower_Bound_<T,Param> >
2726 {
2727     template <class Event,class FSM,class STATE >
2728     struct state_action_result
2729     {
2730         typedef typename get_iterator<
2731             typename ::boost::remove_reference<
2732                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2733     };
2734     template <class EVT,class FSM,class SourceState,class TargetState>
2735     struct transition_action_result
2736     {
2737         typedef typename get_iterator<
2738             typename ::boost::remove_reference<
2739                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2740     };
2741     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2742
2743     template <class EVT,class FSM,class SourceState,class TargetState>
2744     typename ::boost::enable_if<
2745         typename ::boost::mpl::has_key<
2746             typename T::tag_type,action_tag>::type,
2747             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2748         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2749     {
2750         return (T()(evt,fsm,src,tgt)).lower_bound(Param()(evt,fsm,src,tgt));
2751     }
2752     template <class Event,class FSM,class STATE>
2753     typename ::boost::enable_if<
2754         typename ::boost::mpl::has_key<
2755             typename T::tag_type,state_action_tag>::type,
2756             typename state_action_result<Event,FSM,STATE>::type >::type
2757         operator()(Event const& evt,FSM& fsm,STATE& state )const
2758     {
2759         return (T()(evt,fsm,state)).lower_bound(Param()(evt,fsm,state));
2760     }
2761 };
2762
2763 struct associative_lower_bound_tag {};
2764 struct Associative_Lower_Bound_Helper: proto::extends< proto::terminal<associative_lower_bound_tag>::type,
2765                                                        Associative_Lower_Bound_Helper, boost::msm::sm_domain>
2766 {
2767     Associative_Lower_Bound_Helper(){}
2768     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2769 #ifdef BOOST_MSVC
2770  ,class Arg6
2771 #endif
2772 >
2773     struct In
2774     {
2775         typedef Associative_Lower_Bound_<Arg1,Arg2> type;
2776     };
2777 };
2778 Associative_Lower_Bound_Helper const associative_lower_bound_;
2779
2780 template <class T, class Param>
2781 struct Associative_Upper_Bound_ : euml_action<Associative_Upper_Bound_<T,Param> >
2782 {
2783     template <class Event,class FSM,class STATE >
2784     struct state_action_result
2785     {
2786         typedef typename get_iterator<
2787             typename ::boost::remove_reference<
2788                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2789     };
2790     template <class EVT,class FSM,class SourceState,class TargetState>
2791     struct transition_action_result
2792     {
2793         typedef typename get_iterator<
2794             typename ::boost::remove_reference<
2795                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2796     };
2797     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2798
2799     template <class EVT,class FSM,class SourceState,class TargetState>
2800     typename ::boost::enable_if<
2801         typename ::boost::mpl::has_key<
2802             typename T::tag_type,action_tag>::type,
2803             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2804         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2805     {
2806         return (T()(evt,fsm,src,tgt)).upper_bound(Param()(evt,fsm,src,tgt));
2807     }
2808     template <class Event,class FSM,class STATE>
2809     typename ::boost::enable_if<
2810         typename ::boost::mpl::has_key<
2811             typename T::tag_type,state_action_tag>::type,
2812             typename state_action_result<Event,FSM,STATE>::type >::type
2813         operator()(Event const& evt,FSM& fsm,STATE& state )const
2814     {
2815         return (T()(evt,fsm,state)).upper_bound(Param()(evt,fsm,state));
2816     }
2817 };
2818
2819 struct associative_upper_bound_tag {};
2820 struct Associative_Upper_Bound_Helper: proto::extends< proto::terminal<associative_upper_bound_tag>::type,
2821                                                        Associative_Upper_Bound_Helper, boost::msm::sm_domain>
2822 {
2823     Associative_Upper_Bound_Helper(){}
2824     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2825 #ifdef BOOST_MSVC
2826  ,class Arg6
2827 #endif
2828 >
2829     struct In
2830     {
2831         typedef Associative_Upper_Bound_<Arg1,Arg2> type;
2832     };
2833 };
2834 Associative_Upper_Bound_Helper const associative_upper_bound_;
2835
2836 template <class T>
2837 struct First_ : euml_action<First_<T> >
2838 {
2839     template <class Event,class FSM,class STATE >
2840     struct state_action_result
2841     {
2842         typedef typename get_first_type<
2843             typename ::boost::remove_reference<
2844                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2845     };
2846     template <class EVT,class FSM,class SourceState,class TargetState>
2847     struct transition_action_result
2848     {
2849         typedef typename get_first_type<
2850             typename ::boost::remove_reference<
2851                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2852     };
2853     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2854
2855     template <class EVT,class FSM,class SourceState,class TargetState>
2856     typename ::boost::enable_if<
2857         typename ::boost::mpl::has_key<
2858             typename T::tag_type,action_tag>::type,
2859             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2860         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2861     {
2862         return (T()(evt,fsm,src,tgt)).first;
2863     }
2864     template <class Event,class FSM,class STATE>
2865     typename ::boost::enable_if<
2866         typename ::boost::mpl::has_key<
2867             typename T::tag_type,state_action_tag>::type,
2868             typename state_action_result<Event,FSM,STATE>::type >::type
2869         operator()(Event const& evt,FSM& fsm,STATE& state )const
2870     {
2871         return (T()(evt,fsm,state)).first;
2872     }
2873 };
2874
2875 struct first_tag {};
2876 struct First_Helper: proto::extends< proto::terminal<first_tag>::type, First_Helper, boost::msm::sm_domain>
2877 {
2878     First_Helper(){}
2879     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2880 #ifdef BOOST_MSVC
2881  ,class Arg6
2882 #endif
2883 >
2884     struct In
2885     {
2886         typedef First_<Arg1> type;
2887     };
2888 };
2889 First_Helper const first_;
2890
2891 template <class T>
2892 struct Second_ : euml_action<Second_<T> >
2893 {
2894     template <class Event,class FSM,class STATE >
2895     struct state_action_result
2896     {
2897         typedef typename get_second_type<
2898             typename ::boost::remove_reference<
2899                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2900     };
2901     template <class EVT,class FSM,class SourceState,class TargetState>
2902     struct transition_action_result
2903     {
2904         typedef typename get_second_type<
2905             typename ::boost::remove_reference<
2906                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2907     };
2908     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2909
2910     template <class EVT,class FSM,class SourceState,class TargetState>
2911     typename ::boost::enable_if<
2912         typename ::boost::mpl::has_key<
2913             typename T::tag_type,action_tag>::type,
2914             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2915         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2916     {
2917         return (T()(evt,fsm,src,tgt)).second;
2918     }
2919     template <class Event,class FSM,class STATE>
2920     typename ::boost::enable_if<
2921         typename ::boost::mpl::has_key<
2922             typename T::tag_type,state_action_tag>::type,
2923             typename state_action_result<Event,FSM,STATE>::type >::type
2924         operator()(Event const& evt,FSM& fsm,STATE& state )const
2925     {
2926         return (T()(evt,fsm,state)).second;
2927     }
2928 };
2929
2930 struct second_tag {};
2931 struct Second_Helper: proto::extends< proto::terminal<second_tag>::type, Second_Helper, boost::msm::sm_domain>
2932 {
2933     Second_Helper(){}
2934     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2935 #ifdef BOOST_MSVC
2936  ,class Arg6
2937 #endif
2938 >
2939     struct In
2940     {
2941         typedef Second_<Arg1> type;
2942     };
2943 };
2944 Second_Helper const second_;
2945
2946 template <class T, class Param>
2947 struct Associative_Equal_Range_ : euml_action<Associative_Equal_Range_<T,Param> >
2948 {
2949     template <class Event,class FSM,class STATE >
2950     struct state_action_result
2951     {
2952         typedef std::pair<
2953             typename get_iterator<
2954                 typename ::boost::remove_reference<
2955                     typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type,
2956             typename get_iterator<
2957                 typename ::boost::remove_reference<
2958                     typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type > type;
2959     };
2960     template <class EVT,class FSM,class SourceState,class TargetState>
2961     struct transition_action_result
2962     {
2963         typedef std::pair<
2964             typename get_iterator<
2965                 typename ::boost::remove_reference<
2966                     typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type,
2967             typename get_iterator<
2968                 typename ::boost::remove_reference<
2969                     typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type > type;
2970     };
2971     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
2972
2973     template <class EVT,class FSM,class SourceState,class TargetState>
2974     typename ::boost::enable_if<
2975         typename ::boost::mpl::has_key<
2976             typename T::tag_type,action_tag>::type,
2977             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2978         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2979     {
2980         return (T()(evt,fsm,src,tgt)).equal_range(Param()(evt,fsm,src,tgt));
2981     }
2982     template <class Event,class FSM,class STATE>
2983     typename ::boost::enable_if<
2984         typename ::boost::mpl::has_key<
2985             typename T::tag_type,state_action_tag>::type,
2986             typename state_action_result<Event,FSM,STATE>::type >::type
2987         operator()(Event const& evt,FSM& fsm,STATE& state )const
2988     {
2989         return (T()(evt,fsm,state)).equal_range(Param()(evt,fsm,state));
2990     }
2991 };
2992
2993 struct associative_equal_range_tag {};
2994 struct Associative_Equal_Range_Helper: proto::extends< proto::terminal<associative_equal_range_tag>::type,
2995                                                        Associative_Equal_Range_Helper, boost::msm::sm_domain>
2996 {
2997     Associative_Equal_Range_Helper(){}
2998     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2999 #ifdef BOOST_MSVC
3000  ,class Arg6
3001 #endif
3002 >
3003     struct In
3004     {
3005         typedef Associative_Equal_Range_<Arg1,Arg2> type;
3006     };
3007 };
3008 Associative_Equal_Range_Helper const associative_equal_range_;
3009
3010 template <class Container,class Param1, class Param2>
3011 struct Substr_ : euml_action<Substr_<Container,Param1,Param2> >
3012 {
3013     template <class Event,class FSM,class STATE >
3014     struct state_action_result
3015     {
3016         typedef typename remove_reference<
3017             typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3018     };
3019     template <class EVT,class FSM,class SourceState,class TargetState>
3020     struct transition_action_result
3021     {
3022         typedef typename remove_reference<
3023             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3024     };
3025     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3026
3027     template <class EVT,class FSM,class SourceState,class TargetState>
3028     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3029        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3030     {
3031         return (Container()(evt,fsm,src,tgt)).
3032             substr(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3033     }
3034     template <class Event,class FSM,class STATE>
3035     typename state_action_result<Event,FSM,STATE>::type
3036         operator()(Event const& evt,FSM& fsm,STATE& state )const
3037     {
3038         return (Container()(evt,fsm,state)).
3039             substr(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3040     }
3041 };
3042 template <class Container>
3043 struct Substr_ <Container,void,void>
3044                 : euml_action<Substr_<Container,void,void> >
3045
3046 {
3047     template <class Event,class FSM,class STATE >
3048     struct state_action_result
3049     {
3050         typedef typename remove_reference<
3051             typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3052     };
3053     template <class EVT,class FSM,class SourceState,class TargetState>
3054     struct transition_action_result
3055     {
3056         typedef typename remove_reference<
3057             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3058     };
3059     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3060
3061     template <class EVT,class FSM,class SourceState,class TargetState>
3062     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3063        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3064     {
3065         return (Container()(evt,fsm,src,tgt)).substr();
3066     }
3067     template <class Event,class FSM,class STATE>
3068     typename state_action_result<Event,FSM,STATE>::type
3069         operator()(Event const& evt,FSM& fsm,STATE& state )const
3070     {
3071         return (Container()(evt,fsm,state)).substr();
3072     }
3073 };
3074
3075 template <class Container,class Param1>
3076 struct Substr_ < Container,Param1,void>
3077                 : euml_action<Substr_<Container,Param1,void> >
3078 {
3079     template <class Event,class FSM,class STATE >
3080     struct state_action_result
3081     {
3082         typedef typename remove_reference<
3083             typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3084     };
3085     template <class EVT,class FSM,class SourceState,class TargetState>
3086     struct transition_action_result
3087     {
3088         typedef typename remove_reference<
3089             typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3090     };
3091     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3092
3093     template <class EVT,class FSM,class SourceState,class TargetState>
3094     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3095        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3096     {
3097         return (Container()(evt,fsm,src,tgt)).substr(Param1()(evt,fsm,src,tgt));
3098     }
3099     template <class Event,class FSM,class STATE>
3100     typename state_action_result<Event,FSM,STATE>::type
3101         operator()(Event const& evt,FSM& fsm,STATE& state )const
3102     {
3103         return (Container()(evt,fsm,state)).substr(Param1()(evt,fsm,state));
3104     }
3105 };
3106 struct substr_tag {};
3107 struct Substr_Helper: proto::extends< proto::terminal<substr_tag>::type, Substr_Helper, boost::msm::sm_domain>
3108 {
3109     Substr_Helper(){}
3110     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3111 #ifdef BOOST_MSVC
3112  ,class Arg6
3113 #endif
3114 >
3115     struct In
3116     {
3117         typedef Substr_<Arg1,Arg2,Arg3> type;
3118     };
3119 };
3120 Substr_Helper const substr_;
3121
3122 template <class Container, class Param1, class Param2, class Param3, class Param4 >
3123 struct StringCompare_ : euml_action<StringCompare_<Container,Param1,Param2,Param3,Param4> >
3124 {
3125     template <class Event,class FSM,class STATE >
3126     struct state_action_result
3127     {
3128         typedef int type;
3129     };
3130     template <class EVT,class FSM,class SourceState,class TargetState>
3131     struct transition_action_result
3132     {
3133         typedef int type;
3134     };
3135     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3136
3137     template <class EVT,class FSM,class SourceState,class TargetState>
3138     typename ::boost::enable_if<
3139         typename ::boost::mpl::has_key<
3140             typename Container::tag_type,action_tag>::type,
3141             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3142      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3143     {
3144         return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3145                                                       Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
3146     }
3147     template <class Event,class FSM,class STATE>
3148     typename ::boost::enable_if<
3149         typename ::boost::mpl::has_key<
3150             typename Container::tag_type,state_action_tag>::type,
3151             typename state_action_result<Event,FSM,STATE>::type >::type
3152      operator()(Event const& evt,FSM& fsm,STATE& state )const
3153     {
3154         return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3155                                                     Param3()(evt,fsm,state),Param4()(evt,fsm,state));
3156     }
3157 };
3158 template <class Container, class Param1 >
3159 struct StringCompare_<Container,Param1,void,void,void>
3160     : euml_action<StringCompare_<Container,Param1,void,void,void> >
3161 {
3162     template <class Event,class FSM,class STATE >
3163     struct state_action_result
3164     {
3165         typedef int type;
3166     };
3167     template <class EVT,class FSM,class SourceState,class TargetState>
3168     struct transition_action_result
3169     {
3170         typedef int type;
3171     };
3172     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3173
3174     template <class EVT,class FSM,class SourceState,class TargetState>
3175     typename ::boost::enable_if<
3176         typename ::boost::mpl::has_key<
3177             typename Container::tag_type,action_tag>::type,
3178             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3179      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3180     {
3181         return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt));
3182     }
3183     template <class Event,class FSM,class STATE>
3184     typename ::boost::enable_if<
3185         typename ::boost::mpl::has_key<
3186             typename Container::tag_type,state_action_tag>::type,
3187             typename state_action_result<Event,FSM,STATE>::type >::type
3188      operator()(Event const& evt,FSM& fsm,STATE& state )const
3189     {
3190         return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state));
3191     }
3192 };
3193
3194 template <class Container, class Param1, class Param2>
3195 struct StringCompare_<Container,Param1,Param2,void,void>
3196                     : euml_action<StringCompare_<Container,Param1,Param2,void,void> >
3197 {
3198     template <class Event,class FSM,class STATE >
3199     struct state_action_result
3200     {
3201         typedef int type;
3202     };
3203     template <class EVT,class FSM,class SourceState,class TargetState>
3204     struct transition_action_result
3205     {
3206         typedef int type;
3207     };
3208     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3209
3210     template <class EVT,class FSM,class SourceState,class TargetState>
3211     typename ::boost::enable_if<
3212         typename ::boost::mpl::has_key<
3213             typename Container::tag_type,action_tag>::type,
3214             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3215      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3216     {
3217         return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3218     }
3219     template <class Event,class FSM,class STATE>
3220     typename ::boost::enable_if<
3221         typename ::boost::mpl::has_key<
3222             typename Container::tag_type,state_action_tag>::type,
3223             typename state_action_result<Event,FSM,STATE>::type >::type
3224      operator()(Event const& evt,FSM& fsm,STATE& state )const
3225     {
3226         return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3227     }
3228 };
3229
3230 template <class Container, class Param1, class Param2, class Param3 >
3231 struct StringCompare_<Container,Param1,Param2,Param3,void>
3232                     : euml_action<StringCompare_<Container,Param1,Param2,Param3,void> >
3233 {
3234     template <class Event,class FSM,class STATE >
3235     struct state_action_result
3236     {
3237         typedef int type;
3238     };
3239     template <class EVT,class FSM,class SourceState,class TargetState>
3240     struct transition_action_result
3241     {
3242         typedef int type;
3243     };
3244     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3245
3246     template <class EVT,class FSM,class SourceState,class TargetState>
3247     typename ::boost::enable_if<
3248         typename ::boost::mpl::has_key<
3249             typename Container::tag_type,action_tag>::type,
3250             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3251      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3252     {
3253         return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3254                                               Param3()(evt,fsm,src,tgt));
3255     }
3256     template <class Event,class FSM,class STATE>
3257     typename ::boost::enable_if<
3258         typename ::boost::mpl::has_key<
3259             typename Container::tag_type,state_action_tag>::type,
3260             typename state_action_result<Event,FSM,STATE>::type >::type
3261      operator()(Event const& evt,FSM& fsm,STATE& state )const
3262     {
3263         return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3264                                             Param3()(evt,fsm,state));
3265     }
3266 };
3267
3268 struct string_compare_tag {};
3269 struct StringCompare_Helper: proto::extends< proto::terminal<string_compare_tag>::type, StringCompare_Helper, boost::msm::sm_domain>
3270 {
3271     StringCompare_Helper(){}
3272     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3273 #ifdef BOOST_MSVC
3274  ,class Arg6
3275 #endif
3276 >
3277     struct In
3278     {
3279         typedef StringCompare_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3280     };
3281 };
3282 StringCompare_Helper const string_compare_;
3283
3284 template <class Container, class Param1, class Param2, class Param3 >
3285 struct Append_ : euml_action<Append_<Container,Param1,Param2,Param3> >
3286 {
3287     template <class Event,class FSM,class STATE >
3288     struct state_action_result
3289     {
3290         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3291     };
3292     template <class EVT,class FSM,class SourceState,class TargetState>
3293     struct transition_action_result
3294     {
3295         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3296     };
3297     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3298
3299     template <class EVT,class FSM,class SourceState,class TargetState>
3300     typename ::boost::enable_if<
3301         typename ::boost::mpl::has_key<
3302             typename Container::tag_type,action_tag>::type,
3303             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3304      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3305     {
3306         return (Container()(evt,fsm,src,tgt)).append (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3307                                                       Param3()(evt,fsm,src,tgt));
3308     }
3309     template <class Event,class FSM,class STATE>
3310     typename ::boost::enable_if<
3311         typename ::boost::mpl::has_key<
3312             typename Container::tag_type,state_action_tag>::type,
3313             typename state_action_result<Event,FSM,STATE>::type >::type
3314      operator()(Event const& evt,FSM& fsm,STATE& state )const
3315     {
3316         return (Container()(evt,fsm,state)).append (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3317                                                     Param3()(evt,fsm,state));
3318     }
3319 };
3320 template <class Container, class Param1>
3321 struct Append_<Container,Param1,void,void>
3322                     : euml_action<Append_<Container,Param1,void,void> >
3323 {
3324     template <class Event,class FSM,class STATE >
3325     struct state_action_result
3326     {
3327         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3328     };
3329     template <class EVT,class FSM,class SourceState,class TargetState>
3330     struct transition_action_result
3331     {
3332         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3333     };
3334     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3335
3336     template <class EVT,class FSM,class SourceState,class TargetState>
3337     typename ::boost::enable_if<
3338         typename ::boost::mpl::has_key<
3339             typename Container::tag_type,action_tag>::type,
3340             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3341      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3342     {
3343         return (Container()(evt,fsm,src,tgt)).append(Param1()(evt,fsm,src,tgt));
3344     }
3345     template <class Event,class FSM,class STATE>
3346     typename ::boost::enable_if<
3347         typename ::boost::mpl::has_key<
3348             typename Container::tag_type,state_action_tag>::type,
3349             typename state_action_result<Event,FSM,STATE>::type >::type
3350      operator()(Event const& evt,FSM& fsm,STATE& state )const
3351     {
3352         return (Container()(evt,fsm,state)).append(Param1()(evt,fsm,state));
3353     }
3354 };
3355
3356 template <class Container, class Param1, class Param2 >
3357 struct Append_<Container,Param1,Param2,void>
3358                     : euml_action<Append_<Container,Param1,Param2,void> >
3359 {
3360     template <class Event,class FSM,class STATE >
3361     struct state_action_result
3362     {
3363         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3364     };
3365     template <class EVT,class FSM,class SourceState,class TargetState>
3366     struct transition_action_result
3367     {
3368         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3369     };
3370     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3371
3372     template <class EVT,class FSM,class SourceState,class TargetState>
3373     typename ::boost::enable_if<
3374         typename ::boost::mpl::has_key<
3375             typename Container::tag_type,action_tag>::type,
3376             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3377      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3378     {
3379         return (Container()(evt,fsm,src,tgt)).append(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3380     }
3381     template <class Event,class FSM,class STATE>
3382     typename ::boost::enable_if<
3383         typename ::boost::mpl::has_key<
3384             typename Container::tag_type,state_action_tag>::type,
3385             typename state_action_result<Event,FSM,STATE>::type >::type
3386      operator()(Event const& evt,FSM& fsm,STATE& state )const
3387     {
3388         return (Container()(evt,fsm,state)).append(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3389     }
3390 };
3391
3392 struct append_tag {};
3393 struct Append_Helper: proto::extends< proto::terminal<append_tag>::type, Append_Helper, boost::msm::sm_domain>
3394 {
3395     Append_Helper(){}
3396     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3397 #ifdef BOOST_MSVC
3398  ,class Arg6
3399 #endif
3400 >
3401     struct In
3402     {
3403         typedef Append_<Arg1,Arg2,Arg3,Arg4> type;
3404     };
3405 };
3406 Append_Helper const append_;
3407
3408 template <class Container, class Param1, class Param2, class Param3, class Param4 >
3409 struct StringInsert_ : euml_action<StringInsert_<Container,Param1,Param2,Param3,Param4> >
3410 {
3411     template <class Event,class FSM,class STATE >
3412     struct state_action_result
3413     {
3414         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3415     };
3416     template <class EVT,class FSM,class SourceState,class TargetState>
3417     struct transition_action_result
3418     {
3419         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3420     };
3421     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3422
3423     template <class EVT,class FSM,class SourceState,class TargetState>
3424     typename ::boost::enable_if<
3425         typename ::boost::mpl::has_key<
3426             typename Container::tag_type,action_tag>::type,
3427             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3428      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3429     {
3430         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3431                                                      Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
3432     }
3433     template <class Event,class FSM,class STATE>
3434     typename ::boost::enable_if<
3435         typename ::boost::mpl::has_key<
3436             typename Container::tag_type,state_action_tag>::type,
3437             typename state_action_result<Event,FSM,STATE>::type >::type
3438      operator()(Event const& evt,FSM& fsm,STATE& state )const
3439     {
3440         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3441                                                    Param3()(evt,fsm,state),Param4()(evt,fsm,state));
3442     }
3443 };
3444 template <class Container, class Param1, class Param2>
3445 struct StringInsert_ <Container,Param1,Param2,void,void>
3446                 : euml_action<StringInsert_<Container,Param1,Param2,void,void> >
3447 {
3448     template <class Event,class FSM,class STATE >
3449     struct state_action_result
3450     {
3451         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3452     };
3453     template <class EVT,class FSM,class SourceState,class TargetState>
3454     struct transition_action_result
3455     {
3456         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3457     };
3458     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3459
3460     template <class EVT,class FSM,class SourceState,class TargetState>
3461     typename ::boost::enable_if<
3462         typename ::boost::mpl::has_key<
3463             typename Container::tag_type,action_tag>::type,
3464             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3465      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3466     {
3467         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3468     }
3469     template <class Event,class FSM,class STATE>
3470     typename ::boost::enable_if<
3471         typename ::boost::mpl::has_key<
3472             typename Container::tag_type,state_action_tag>::type,
3473             typename state_action_result<Event,FSM,STATE>::type >::type
3474      operator()(Event const& evt,FSM& fsm,STATE& state )const
3475     {
3476         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3477     }
3478 };
3479 template <class Container, class Param1, class Param2, class Param3>
3480 struct StringInsert_<Container,Param1,Param2,Param3,void>
3481                     : euml_action<StringInsert_<Container,Param1,Param2,Param3,void> >
3482 {
3483     template <class Event,class FSM,class STATE >
3484     struct state_action_result
3485     {
3486         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3487     };
3488     template <class EVT,class FSM,class SourceState,class TargetState>
3489     struct transition_action_result
3490     {
3491         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3492     };
3493     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3494
3495     template <class EVT,class FSM,class SourceState,class TargetState>
3496     typename ::boost::enable_if<
3497         typename ::boost::mpl::has_key<
3498             typename Container::tag_type,action_tag>::type,
3499             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3500      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3501     {
3502         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3503                                                      Param3()(evt,fsm,src,tgt));
3504     }
3505     template <class Event,class FSM,class STATE>
3506     typename ::boost::enable_if<
3507         typename ::boost::mpl::has_key<
3508             typename Container::tag_type,state_action_tag>::type,
3509             typename state_action_result<Event,FSM,STATE>::type >::type
3510      operator()(Event const& evt,FSM& fsm,STATE& state )const
3511     {
3512         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3513                                                    Param3()(evt,fsm,state));
3514     }
3515 };
3516
3517 struct string_insert_tag {};
3518 struct StringInsert_Helper: proto::extends< proto::terminal<string_insert_tag>::type, StringInsert_Helper, boost::msm::sm_domain>
3519 {
3520     StringInsert_Helper(){}
3521     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3522 #ifdef BOOST_MSVC
3523  ,class Arg6
3524 #endif
3525 >
3526     struct In
3527     {
3528         typedef StringInsert_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3529     };
3530 };
3531 StringInsert_Helper const string_insert_;
3532
3533 template <class Container,class Param1, class Param2>
3534 struct StringErase_ : euml_action<StringErase_<Container,Param1,Param2> >
3535 {
3536     template <class Event,class FSM,class STATE >
3537     struct state_action_result
3538     {
3539         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3540     };
3541     template <class EVT,class FSM,class SourceState,class TargetState>
3542     struct transition_action_result
3543     {
3544         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3545     };
3546     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3547
3548     template <class EVT,class FSM,class SourceState,class TargetState>
3549     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3550        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3551     {
3552         return (Container()(evt,fsm,src,tgt)).
3553             erase(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3554     }
3555     template <class Event,class FSM,class STATE>
3556     typename state_action_result<Event,FSM,STATE>::type
3557         operator()(Event const& evt,FSM& fsm,STATE& state )const
3558     {
3559         return (Container()(evt,fsm,state)).
3560             erase(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3561     }
3562 };
3563 template <class Container>
3564 struct StringErase_ <Container,void,void>
3565                 : euml_action<StringErase_<Container,void,void> >
3566
3567 {
3568     template <class Event,class FSM,class STATE >
3569     struct state_action_result
3570     {
3571         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3572     };
3573     template <class EVT,class FSM,class SourceState,class TargetState>
3574     struct transition_action_result
3575     {
3576         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3577     };
3578     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3579
3580     template <class EVT,class FSM,class SourceState,class TargetState>
3581     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3582        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3583     {
3584         return (Container()(evt,fsm,src,tgt)).erase();
3585     }
3586     template <class Event,class FSM,class STATE>
3587     typename state_action_result<Event,FSM,STATE>::type
3588         operator()(Event const& evt,FSM& fsm,STATE& state )const
3589     {
3590         return (Container()(evt,fsm,state)).erase();
3591     }
3592 };
3593
3594 template <class Container,class Param1>
3595 struct StringErase_ <Container,Param1,void>
3596                 : euml_action<StringErase_<Container,Param1,void> >
3597 {
3598     template <class Event,class FSM,class STATE >
3599     struct state_action_result
3600     {
3601         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3602     };
3603     template <class EVT,class FSM,class SourceState,class TargetState>
3604     struct transition_action_result
3605     {
3606         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3607     };
3608     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3609
3610     template <class EVT,class FSM,class SourceState,class TargetState>
3611     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3612        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3613     {
3614         return (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
3615     }
3616     template <class Event,class FSM,class STATE>
3617     typename state_action_result<Event,FSM,STATE>::type
3618         operator()(Event const& evt,FSM& fsm,STATE& state )const
3619     {
3620         return (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
3621     }
3622 };
3623
3624 struct string_erase_tag {};
3625 struct StringErase_Helper: proto::extends< proto::terminal<string_erase_tag>::type, StringErase_Helper, boost::msm::sm_domain>
3626 {
3627     StringErase_Helper(){}
3628     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3629 #ifdef BOOST_MSVC
3630  ,class Arg6
3631 #endif
3632 >
3633     struct In
3634     {
3635         typedef StringErase_<Arg1,Arg2,Arg3> type;
3636     };
3637 };
3638 StringErase_Helper const string_erase_;
3639
3640 template <class Container, class Param1, class Param2, class Param3 >
3641 struct StringAssign_ : euml_action<StringAssign_<Container,Param1,Param2,Param3> >
3642 {
3643     template <class Event,class FSM,class STATE >
3644     struct state_action_result
3645     {
3646         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3647     };
3648     template <class EVT,class FSM,class SourceState,class TargetState>
3649     struct transition_action_result
3650     {
3651         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3652     };
3653     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3654
3655     template <class EVT,class FSM,class SourceState,class TargetState>
3656     typename ::boost::enable_if<
3657         typename ::boost::mpl::has_key<
3658             typename Container::tag_type,action_tag>::type,
3659             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3660      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3661     {
3662         return (Container()(evt,fsm,src,tgt)).assign (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3663                                                       Param3()(evt,fsm,src,tgt));
3664     }
3665     template <class Event,class FSM,class STATE>
3666     typename ::boost::enable_if<
3667         typename ::boost::mpl::has_key<
3668             typename Container::tag_type,state_action_tag>::type,
3669             typename state_action_result<Event,FSM,STATE>::type >::type
3670      operator()(Event const& evt,FSM& fsm,STATE& state )const
3671     {
3672         return (Container()(evt,fsm,state)).assign (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3673                                                     Param3()(evt,fsm,state));
3674     }
3675 };
3676 template <class Container,class Param1>
3677 struct StringAssign_ <
3678         Container,Param1,void,void>
3679                 : euml_action<StringAssign_<Container,Param1,void,void> >
3680 {
3681     template <class Event,class FSM,class STATE >
3682     struct state_action_result
3683     {
3684         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3685     };
3686     template <class EVT,class FSM,class SourceState,class TargetState>
3687     struct transition_action_result
3688     {
3689         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3690     };
3691     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3692
3693     template <class EVT,class FSM,class SourceState,class TargetState>
3694     typename ::boost::enable_if<
3695         typename ::boost::mpl::has_key<
3696             typename Container::tag_type,action_tag>::type,
3697             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3698      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3699     {
3700         return (Container()(evt,fsm,src,tgt)).assign(Param1()(evt,fsm,src,tgt));
3701     }
3702     template <class Event,class FSM,class STATE>
3703     typename ::boost::enable_if<
3704         typename ::boost::mpl::has_key<
3705             typename Container::tag_type,state_action_tag>::type,
3706             typename state_action_result<Event,FSM,STATE>::type >::type
3707      operator()(Event const& evt,FSM& fsm,STATE& state )const
3708     {
3709         return (Container()(evt,fsm,state)).assign(Param1()(evt,fsm,state));
3710     }
3711 };
3712
3713 template <class Container, class Param1, class Param2 >
3714 struct StringAssign_<Container,Param1,Param2,void>
3715                     : euml_action<StringAssign_<Container,Param1,Param2,void> >
3716 {
3717     template <class Event,class FSM,class STATE >
3718     struct state_action_result
3719     {
3720         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3721     };
3722     template <class EVT,class FSM,class SourceState,class TargetState>
3723     struct transition_action_result
3724     {
3725         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3726     };
3727     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3728
3729     template <class EVT,class FSM,class SourceState,class TargetState>
3730     typename ::boost::enable_if<
3731         typename ::boost::mpl::has_key<
3732             typename Container::tag_type,action_tag>::type,
3733             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3734      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3735     {
3736         return (Container()(evt,fsm,src,tgt)).assign(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3737     }
3738     template <class Event,class FSM,class STATE>
3739     typename ::boost::enable_if<
3740         typename ::boost::mpl::has_key<
3741             typename Container::tag_type,state_action_tag>::type,
3742             typename state_action_result<Event,FSM,STATE>::type >::type
3743      operator()(Event const& evt,FSM& fsm,STATE& state )const
3744     {
3745         return (Container()(evt,fsm,state)).assign(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3746     }
3747 };
3748 struct assign_tag {};
3749 struct StringAssign_Helper: proto::extends< proto::terminal<assign_tag>::type, StringAssign_Helper, boost::msm::sm_domain>
3750 {
3751     StringAssign_Helper(){}
3752     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3753 #ifdef BOOST_MSVC
3754  ,class Arg6
3755 #endif
3756 >
3757     struct In
3758     {
3759         typedef StringAssign_<Arg1,Arg2,Arg3,Arg4> type;
3760     };
3761 };
3762 StringAssign_Helper const string_assign_;
3763
3764 template <class Container,class Param1, class Param2, class Param3, class Param4>
3765 struct StringReplace_ : euml_action<StringReplace_<Container,Param1,Param2,Param3,Param4> >
3766 {
3767     template <class Event,class FSM,class STATE >
3768     struct state_action_result
3769     {
3770         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3771     };
3772     template <class EVT,class FSM,class SourceState,class TargetState>
3773     struct transition_action_result
3774     {
3775         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3776     };
3777     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3778
3779     template <class EVT,class FSM,class SourceState,class TargetState>
3780     typename ::boost::enable_if<
3781         typename ::boost::mpl::has_key<
3782             typename Container::tag_type,action_tag>::type,
3783             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3784      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3785     {
3786         return (Container()(evt,fsm,src,tgt)).replace (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3787                                                        Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
3788     }
3789     template <class Event,class FSM,class STATE>
3790     typename ::boost::enable_if<
3791         typename ::boost::mpl::has_key<
3792             typename Container::tag_type,state_action_tag>::type,
3793             typename state_action_result<Event,FSM,STATE>::type >::type
3794      operator()(Event const& evt,FSM& fsm,STATE& state )const
3795     {
3796         return (Container()(evt,fsm,state)).replace (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3797                                                      Param3()(evt,fsm,state),Param4()(evt,fsm,state));
3798     }
3799 };
3800
3801 template <class Container,class Param1, class Param2, class Param3>
3802 struct StringReplace_<Container,Param1,Param2,Param3,void>
3803                     : euml_action<StringReplace_<Container,Param1,Param2,Param3,void> >
3804 {
3805     template <class Event,class FSM,class STATE >
3806     struct state_action_result
3807     {
3808         typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3809     };
3810     template <class EVT,class FSM,class SourceState,class TargetState>
3811     struct transition_action_result
3812     {
3813         typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3814     };
3815     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3816
3817     template <class EVT,class FSM,class SourceState,class TargetState>
3818     typename ::boost::enable_if<
3819         typename ::boost::mpl::has_key<
3820             typename Container::tag_type,action_tag>::type,
3821             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3822      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3823     {
3824         return (Container()(evt,fsm,src,tgt)).replace(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3825                                                       Param3()(evt,fsm,src,tgt));
3826     }
3827     template <class Event,class FSM,class STATE>
3828     typename ::boost::enable_if<
3829         typename ::boost::mpl::has_key<
3830             typename Container::tag_type,state_action_tag>::type,
3831             typename state_action_result<Event,FSM,STATE>::type >::type
3832      operator()(Event const& evt,FSM& fsm,STATE& state )const
3833     {
3834         return (Container()(evt,fsm,state)).replace(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3835                                                     Param3()(evt,fsm,state));
3836     }
3837 };
3838
3839 struct string_replace_tag {};
3840 struct StringReplace_Helper: proto::extends< proto::terminal<string_replace_tag>::type, StringReplace_Helper, boost::msm::sm_domain>
3841 {
3842     StringReplace_Helper(){}
3843     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3844 #ifdef BOOST_MSVC
3845  ,class Arg6
3846 #endif
3847 >
3848     struct In
3849     {
3850         typedef StringReplace_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3851     };
3852 };
3853 StringReplace_Helper const string_replace_;
3854
3855 template <class Container>
3856 struct CStr_ : euml_action<CStr_<Container> >
3857 {
3858     template <class Event,class FSM,class STATE >
3859     struct state_action_result
3860     {
3861         typedef typename ::boost::add_const<
3862             typename get_value_type<
3863                 typename ::boost::remove_reference<
3864                     typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type>::type* type;
3865     };
3866     template <class EVT,class FSM,class SourceState,class TargetState>
3867     struct transition_action_result
3868     {
3869         typedef typename ::boost::add_const<
3870             typename get_value_type<
3871                 typename ::boost::remove_reference<
3872                     typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type>::type* type;
3873     };
3874     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3875
3876     template <class EVT,class FSM,class SourceState,class TargetState>
3877     typename ::boost::enable_if<
3878         typename ::boost::mpl::has_key<
3879             typename Container::tag_type,action_tag>::type,
3880             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3881      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3882     {
3883         return (Container()(evt,fsm,src,tgt)).c_str();
3884     }
3885     template <class Event,class FSM,class STATE>
3886     typename ::boost::enable_if<
3887         typename ::boost::mpl::has_key<
3888             typename Container::tag_type,state_action_tag>::type,
3889             typename state_action_result<Event,FSM,STATE>::type >::type
3890      operator()(Event const& evt,FSM& fsm,STATE& state )const
3891     {
3892         return (Container()(evt,fsm,state)).c_str();
3893     }
3894 };
3895 struct c_str_tag {};
3896 struct CStr_Helper: proto::extends< proto::terminal<c_str_tag>::type, CStr_Helper, boost::msm::sm_domain>
3897 {
3898     CStr_Helper(){}
3899     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3900 #ifdef BOOST_MSVC
3901  ,class Arg6
3902 #endif
3903 >
3904     struct In
3905     {
3906         typedef CStr_<Arg1> type;
3907     };
3908 };
3909 CStr_Helper const c_str_;
3910
3911 template <class Container>
3912 struct StringData_ : euml_action<StringData_<Container> >
3913 {
3914     template <class Event,class FSM,class STATE >
3915     struct state_action_result
3916     {
3917         typedef typename ::boost::add_const<
3918             typename get_value_type<
3919                 typename ::boost::remove_reference<
3920                     typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type>::type* type;
3921     };
3922     template <class EVT,class FSM,class SourceState,class TargetState>
3923     struct transition_action_result
3924     {
3925         typedef typename ::boost::add_const<
3926             typename get_value_type<
3927                 typename ::boost::remove_reference<
3928                     typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type>::type* type;
3929     };
3930     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3931
3932     template <class EVT,class FSM,class SourceState,class TargetState>
3933     typename ::boost::enable_if<
3934         typename ::boost::mpl::has_key<
3935             typename Container::tag_type,action_tag>::type,
3936             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3937      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3938     {
3939         return (Container()(evt,fsm,src,tgt)).data();
3940     }
3941     template <class Event,class FSM,class STATE>
3942     typename ::boost::enable_if<
3943         typename ::boost::mpl::has_key<
3944             typename Container::tag_type,state_action_tag>::type,
3945             typename state_action_result<Event,FSM,STATE>::type >::type
3946      operator()(Event const& evt,FSM& fsm,STATE& state )const
3947     {
3948         return (Container()(evt,fsm,state)).data();
3949     }
3950 };
3951 struct string_data_tag {};
3952 struct StringData_Helper: proto::extends< proto::terminal<string_data_tag>::type, StringData_Helper, boost::msm::sm_domain>
3953 {
3954     StringData_Helper(){}
3955     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3956 #ifdef BOOST_MSVC
3957  ,class Arg6
3958 #endif
3959 >
3960     struct In
3961     {
3962         typedef StringData_<Arg1> type;
3963     };
3964 };
3965 StringData_Helper const string_data_;
3966
3967 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
3968 struct StringCopy_ : euml_action<StringCopy_<Container,Param1,Param2,Param3,Enable> >
3969 {
3970 };
3971
3972 template <class Container,class Param1, class Param2, class Param3>
3973 struct StringCopy_<
3974     Container,Param1,Param2,Param3,
3975             typename ::boost::enable_if<
3976                                 typename ::boost::is_same<Param3,void>::type
3977                                 >::type
3978                 >
3979                 : euml_action<StringCopy_<Container,Param1,Param2,Param3> >
3980 {
3981     template <class Event,class FSM,class STATE >
3982     struct state_action_result
3983     {
3984         typedef typename get_size_type<
3985             typename ::boost::remove_reference<
3986                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
3987     };
3988     template <class EVT,class FSM,class SourceState,class TargetState>
3989     struct transition_action_result
3990     {
3991         typedef typename get_size_type<
3992             typename ::boost::remove_reference<
3993                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
3994     };
3995     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
3996
3997     template <class EVT,class FSM,class SourceState,class TargetState>
3998     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3999        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
4000     {
4001         return (Container()(evt,fsm,src,tgt)).copy(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
4002     }
4003     template <class Event,class FSM,class STATE>
4004     typename state_action_result<Event,FSM,STATE>::type
4005         operator()(Event const& evt,FSM& fsm,STATE& state )const
4006     {
4007         return (Container()(evt,fsm,state)).copy(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
4008     }
4009 };
4010
4011 template <class Container,class Param1, class Param2, class Param3>
4012 struct StringCopy_<
4013     Container,Param1,Param2,Param3,
4014             typename ::boost::disable_if<
4015                                 typename ::boost::is_same<Param3,void>::type
4016                                 >::type
4017                 >
4018                 : euml_action<StringCopy_<Container,Param1,Param2,Param3> >
4019 {
4020     template <class Event,class FSM,class STATE >
4021     struct state_action_result
4022     {
4023         typedef typename get_size_type<
4024             typename ::boost::remove_reference<
4025                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
4026     };
4027     template <class EVT,class FSM,class SourceState,class TargetState>
4028     struct transition_action_result
4029     {
4030         typedef typename get_size_type<
4031             typename ::boost::remove_reference<
4032                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
4033     };
4034     typedef ::boost::fusion::set<state_action_tag,action_tag> tag_type;
4035
4036     template <class EVT,class FSM,class SourceState,class TargetState>
4037     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
4038        operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
4039     {
4040         return (Container()(evt,fsm,src,tgt)).
4041             copy(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
4042     }
4043     template <class Event,class FSM,class STATE>
4044     typename state_action_result<Event,FSM,STATE>::type
4045         operator()(Event const& evt,FSM& fsm,STATE& state )const
4046     {
4047         return (Container()(evt,fsm,state)).
4048             copy(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
4049     }
4050 };
4051
4052 struct string_copy_tag {};
4053 struct StringCopy_Helper: proto::extends< proto::terminal<string_copy_tag>::type, StringCopy_Helper, boost::msm::sm_domain>
4054 {
4055     StringCopy_Helper(){}
4056     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
4057 #ifdef BOOST_MSVC
4058  ,class Arg6
4059 #endif
4060 >
4061     struct In
4062     {
4063         typedef StringCopy_<Arg1,Arg2,Arg3,Arg4> type;
4064     };
4065 };
4066 StringCopy_Helper const string_copy_;
4067
4068 }}}}
4069
4070 #endif //BOOST_MSM_FRONT_EUML_CONTAINER_H