Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2024-11-16 09:21:27 

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

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!