1 // Copyright 2008 Christophe Henry
2 // henry UNDERSCORE christophe AT hotmail DOT com
3 // This is an extended version of the state machine available in the boost::mpl library
4 // Distributed under the same license as the original.
5 // Copyright for the original version:
6 // Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
7 // under the Boost Software License, Version 1.0. (See accompanying
8 // file LICENSE_1_0.txt or copy at
9 // http://www.boost.org/LICENSE_1_0.txt)
11 #ifndef BOOST_MSM_FRONT_EUML_CONTAINER_H
12 #define BOOST_MSM_FRONT_EUML_CONTAINER_H
15 #include <boost/msm/front/euml/common.hpp>
16 #include <boost/utility/enable_if.hpp>
17 #include <boost/mpl/has_key.hpp>
18 #include <boost/mpl/set.hpp>
19 #include <boost/mpl/not.hpp>
20 #include <boost/msm/front/euml/operator.hpp>
21 #include <boost/type_traits.hpp>
23 BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
25 namespace boost { namespace msm { namespace front { namespace euml
29 struct Front_ : euml_action<Front_<T> >
31 template <class Event,class FSM,class STATE >
32 struct state_action_result
34 typedef typename get_reference<
35 typename ::boost::remove_reference<
36 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
38 template <class EVT,class FSM,class SourceState,class TargetState>
39 struct transition_action_result
41 typedef typename get_reference<
42 typename ::boost::remove_reference<
43 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
45 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
47 template <class EVT,class FSM,class SourceState,class TargetState>
48 typename ::boost::enable_if<
49 typename ::boost::mpl::has_key<
50 typename T::tag_type,action_tag>::type,
51 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
52 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
54 return (T()(evt,fsm,src,tgt)).front();
56 template <class Event,class FSM,class STATE>
57 typename ::boost::enable_if<
58 typename ::boost::mpl::has_key<
59 typename T::tag_type,state_action_tag>::type,
60 typename state_action_result<Event,FSM,STATE>::type >::type
61 operator()(Event const& evt,FSM& fsm,STATE& state )const
63 return (T()(evt,fsm,state)).front();
68 struct Front_Helper: proto::extends< proto::terminal<front_tag>::type, Front_Helper, boost::msm::sm_domain>
71 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
78 typedef Front_<Arg1> type;
81 Front_Helper const front_;
84 struct Back_ : euml_action<Back_<T> >
86 template <class Event,class FSM,class STATE >
87 struct state_action_result
89 typedef typename get_reference<
90 typename ::boost::remove_reference<
91 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
93 template <class EVT,class FSM,class SourceState,class TargetState>
94 struct transition_action_result
96 typedef typename get_reference<
97 typename ::boost::remove_reference<
98 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
100 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
102 template <class EVT,class FSM,class SourceState,class TargetState>
103 typename ::boost::enable_if<
104 typename ::boost::mpl::has_key<
105 typename T::tag_type,action_tag>::type,
106 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
107 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
109 return (T()(evt,fsm,src,tgt)).back();
111 template <class Event,class FSM,class STATE>
112 typename ::boost::enable_if<
113 typename ::boost::mpl::has_key<
114 typename T::tag_type,state_action_tag>::type,
115 typename state_action_result<Event,FSM,STATE>::type >::type
116 operator()(Event const& evt,FSM& fsm,STATE& state )const
118 return (T()(evt,fsm,state)).back();
123 struct Back_Helper: proto::extends< proto::terminal<back_tag>::type, Back_Helper, boost::msm::sm_domain>
126 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
133 typedef Back_<Arg1> type;
136 Back_Helper const back_;
139 struct Begin_ : euml_action<Begin_<T> >
141 template <class Event,class FSM,class STATE >
142 struct state_action_result
144 typedef typename get_iterator<
145 typename ::boost::remove_reference<
146 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
148 template <class EVT,class FSM,class SourceState,class TargetState>
149 struct transition_action_result
151 typedef typename get_iterator<
152 typename ::boost::remove_reference<
153 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
155 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
157 template <class EVT,class FSM,class SourceState,class TargetState>
158 typename ::boost::enable_if<
159 typename ::boost::mpl::has_key<
160 typename T::tag_type,action_tag>::type,
161 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
162 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
164 return (T()(evt,fsm,src,tgt)).begin();
166 template <class Event,class FSM,class STATE>
167 typename ::boost::enable_if<
168 typename ::boost::mpl::has_key<
169 typename T::tag_type,state_action_tag>::type,
170 typename state_action_result<Event,FSM,STATE>::type >::type
171 operator()(Event const& evt,FSM& fsm,STATE& state )const
173 return (T()(evt,fsm,state)).begin();
178 struct Begin_Helper: proto::extends< proto::terminal<begin_tag>::type, Begin_Helper, boost::msm::sm_domain>
181 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
188 typedef Begin_<Arg1> type;
191 Begin_Helper const begin_;
194 struct End_ : euml_action<End_<T> >
196 template <class Event,class FSM,class STATE >
197 struct state_action_result
199 typedef typename get_iterator<
200 typename ::boost::remove_reference<
201 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
203 template <class EVT,class FSM,class SourceState,class TargetState>
204 struct transition_action_result
206 typedef typename get_iterator<
207 typename ::boost::remove_reference<
208 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
210 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
212 template <class EVT,class FSM,class SourceState,class TargetState>
213 typename ::boost::enable_if<
214 typename ::boost::mpl::has_key<
215 typename T::tag_type,action_tag>::type,
216 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
217 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
219 return (T()(evt,fsm,src,tgt)).end();
221 template <class Event,class FSM,class STATE>
222 typename ::boost::enable_if<
223 typename ::boost::mpl::has_key<
224 typename T::tag_type,state_action_tag>::type,
225 typename state_action_result<Event,FSM,STATE>::type >::type
226 operator()(Event const& evt,FSM& fsm,STATE& state )const
228 return (T()(evt,fsm,state)).end();
232 struct End_Helper: proto::extends< proto::terminal<end_tag>::type, End_Helper, boost::msm::sm_domain>
235 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
242 typedef End_<Arg1> type;
245 End_Helper const end_;
248 struct RBegin_ : euml_action<RBegin_<T> >
250 template <class Event,class FSM,class STATE >
251 struct state_action_result
253 typedef typename get_reverse_iterator<
254 typename ::boost::remove_reference<
255 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
257 template <class EVT,class FSM,class SourceState,class TargetState>
258 struct transition_action_result
260 typedef typename get_reverse_iterator<
261 typename ::boost::remove_reference<
262 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
264 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
266 template <class EVT,class FSM,class SourceState,class TargetState>
267 typename ::boost::enable_if<
268 typename ::boost::mpl::has_key<
269 typename T::tag_type,action_tag>::type,
270 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
271 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
273 return (T()(evt,fsm,src,tgt)).rbegin();
275 template <class Event,class FSM,class STATE>
276 typename ::boost::enable_if<
277 typename ::boost::mpl::has_key<
278 typename T::tag_type,state_action_tag>::type,
279 typename state_action_result<Event,FSM,STATE>::type >::type
280 operator()(Event const& evt,FSM& fsm,STATE& state )const
282 return (T()(evt,fsm,state)).rbegin();
286 struct rbegin_tag {};
287 struct RBegin_Helper: proto::extends< proto::terminal<rbegin_tag>::type, RBegin_Helper, boost::msm::sm_domain>
290 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
297 typedef RBegin_<Arg1> type;
300 RBegin_Helper const rbegin_;
303 struct REnd_ : euml_action<REnd_<T> >
305 template <class Event,class FSM,class STATE >
306 struct state_action_result
308 typedef typename get_reverse_iterator<
309 typename ::boost::remove_reference<
310 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
312 template <class EVT,class FSM,class SourceState,class TargetState>
313 struct transition_action_result
315 typedef typename get_reverse_iterator<
316 typename ::boost::remove_reference<
317 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
319 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
321 template <class EVT,class FSM,class SourceState,class TargetState>
322 typename ::boost::enable_if<
323 typename ::boost::mpl::has_key<
324 typename T::tag_type,action_tag>::type,
325 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
326 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
328 return (T()(evt,fsm,src,tgt)).rend();
330 template <class Event,class FSM,class STATE>
331 typename ::boost::enable_if<
332 typename ::boost::mpl::has_key<
333 typename T::tag_type,state_action_tag>::type,
334 typename state_action_result<Event,FSM,STATE>::type >::type
335 operator()(Event const& evt,FSM& fsm,STATE& state )const
337 return (T()(evt,fsm,state)).rend();
341 struct REnd_Helper: proto::extends< proto::terminal<rend_tag>::type, REnd_Helper, boost::msm::sm_domain>
344 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
351 typedef REnd_<Arg1> type;
354 REnd_Helper const rend_;
356 template <class Container,class Element>
357 struct Push_Back_ : euml_action<Push_Back_<Container,Element> >
359 template <class Event,class FSM,class STATE >
360 struct state_action_result
364 template <class EVT,class FSM,class SourceState,class TargetState>
365 struct transition_action_result
369 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
371 template <class EVT,class FSM,class SourceState,class TargetState>
372 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
374 (Container()(evt,fsm,src,tgt)).push_back(Element()(evt,fsm,src,tgt));
376 template <class Event,class FSM,class STATE>
377 void operator()(Event const& evt,FSM& fsm,STATE& state )const
379 (Container()(evt,fsm,state)).push_back(Element()(evt,fsm,state));
382 struct push_back_tag {};
383 struct Push_Back_Helper: proto::extends< proto::terminal<push_back_tag>::type, Push_Back_Helper, boost::msm::sm_domain>
386 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
393 typedef Push_Back_<Arg1,Arg2> type;
396 Push_Back_Helper const push_back_;
398 template <class Container>
399 struct Pop_Back_ : euml_action<Pop_Back_<Container> >
401 template <class Event,class FSM,class STATE >
402 struct state_action_result
406 template <class EVT,class FSM,class SourceState,class TargetState>
407 struct transition_action_result
411 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
413 template <class EVT,class FSM,class SourceState,class TargetState>
414 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
416 (Container()(evt,fsm,src,tgt)).pop_back();
418 template <class Event,class FSM,class STATE>
419 void operator()(Event const& evt,FSM& fsm,STATE& state )const
421 (Container()(evt,fsm,state)).pop_back();
424 struct pop_back_tag {};
425 struct Pop_Back_Helper: proto::extends< proto::terminal<pop_back_tag>::type, Pop_Back_Helper, boost::msm::sm_domain>
428 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
435 typedef Pop_Back_<Arg1> type;
438 Pop_Back_Helper const pop_back_;
440 template <class Container,class Element>
441 struct Push_Front_ : euml_action<Push_Front_<Container,Element> >
443 template <class Event,class FSM,class STATE >
444 struct state_action_result
448 template <class EVT,class FSM,class SourceState,class TargetState>
449 struct transition_action_result
453 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
455 template <class EVT,class FSM,class SourceState,class TargetState>
456 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
458 (Container()(evt,fsm,src,tgt)).push_front(Element()(evt,fsm,src,tgt));
460 template <class Event,class FSM,class STATE>
461 void operator()(Event const& evt,FSM& fsm,STATE& state )const
463 (Container()(evt,fsm,state)).push_front(Element()(evt,fsm,state));
466 struct push_front_tag {};
467 struct Push_Front_Helper: proto::extends< proto::terminal<push_front_tag>::type, Push_Front_Helper, boost::msm::sm_domain>
469 Push_Front_Helper(){}
470 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
477 typedef Push_Front_<Arg1,Arg2> type;
480 Push_Front_Helper const push_front_;
482 template <class Container>
483 struct Pop_Front_ : euml_action<Pop_Front_<Container> >
485 template <class Event,class FSM,class STATE >
486 struct state_action_result
490 template <class EVT,class FSM,class SourceState,class TargetState>
491 struct transition_action_result
495 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
497 template <class EVT,class FSM,class SourceState,class TargetState>
498 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
500 (Container()(evt,fsm,src,tgt)).pop_front();
502 template <class Event,class FSM,class STATE>
503 void operator()(Event const& evt,FSM& fsm,STATE& state )const
505 (Container()(evt,fsm,state)).pop_front();
508 struct pop_front_tag {};
509 struct Pop_Front_Helper: proto::extends< proto::terminal<pop_front_tag>::type, Pop_Front_Helper, boost::msm::sm_domain>
512 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
519 typedef Pop_Front_<Arg1> type;
522 Pop_Front_Helper const pop_front_;
524 template <class Container>
525 struct Clear_ : euml_action<Clear_<Container> >
527 template <class Event,class FSM,class STATE >
528 struct state_action_result
532 template <class EVT,class FSM,class SourceState,class TargetState>
533 struct transition_action_result
537 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
539 template <class EVT,class FSM,class SourceState,class TargetState>
540 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
542 (Container()(evt,fsm,src,tgt)).clear();
544 template <class Event,class FSM,class STATE>
545 void operator()(Event const& evt,FSM& fsm,STATE& state )const
547 (Container()(evt,fsm,state)).clear();
551 struct Clear_Helper: proto::extends< proto::terminal<clear_tag>::type, Clear_Helper, boost::msm::sm_domain>
554 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
561 typedef Clear_<Arg1> type;
564 Clear_Helper const clear_;
566 template <class Container>
567 struct ListReverse_ : euml_action<ListReverse_<Container> >
569 template <class Event,class FSM,class STATE >
570 struct state_action_result
574 template <class EVT,class FSM,class SourceState,class TargetState>
575 struct transition_action_result
579 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
581 template <class EVT,class FSM,class SourceState,class TargetState>
582 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
584 (Container()(evt,fsm,src,tgt)).reverse();
586 template <class Event,class FSM,class STATE>
587 void operator()(Event const& evt,FSM& fsm,STATE& state )const
589 (Container()(evt,fsm,state)).reverse();
592 struct list_reverse_tag {};
593 struct ListReverse_Helper: proto::extends< proto::terminal<list_reverse_tag>::type, ListReverse_Helper, boost::msm::sm_domain>
595 ListReverse_Helper(){}
596 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
603 typedef ListReverse_<Arg1> type;
606 ListReverse_Helper const list_reverse_;
608 template <class Container, class Predicate, class Enable=void>
609 struct ListUnique_ : euml_action<ListUnique_<Container,Predicate,Enable> >
611 template <class Event,class FSM,class STATE >
612 struct state_action_result
616 template <class EVT,class FSM,class SourceState,class TargetState>
617 struct transition_action_result
621 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
623 template <class EVT,class FSM,class SourceState,class TargetState>
624 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
626 (Container()(evt,fsm,src,tgt)).unique();
628 template <class Event,class FSM,class STATE>
629 void operator()(Event const& evt,FSM& fsm,STATE& state )const
631 (Container()(evt,fsm,state)).unique();
634 template <class Container, class Predicate >
635 struct ListUnique_<Container,Predicate,
636 typename ::boost::disable_if<typename ::boost::is_same<Predicate,void>::type >::type>
637 : euml_action<ListUnique_<Container,Predicate> >
639 template <class Event,class FSM,class STATE >
640 struct state_action_result
644 template <class EVT,class FSM,class SourceState,class TargetState>
645 struct transition_action_result
649 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
651 template <class EVT,class FSM,class SourceState,class TargetState>
652 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
654 (Container()(evt,fsm,src,tgt)).unique(Predicate()(evt,fsm,src,tgt));
656 template <class Event,class FSM,class STATE>
657 void operator()(Event const& evt,FSM& fsm,STATE& state )const
659 (Container()(evt,fsm,state)).unique(Predicate()(evt,fsm,state));
662 struct list_unique_tag {};
663 struct ListUnique_Helper: proto::extends< proto::terminal<list_unique_tag>::type, ListUnique_Helper, boost::msm::sm_domain>
665 ListUnique_Helper(){}
666 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
673 typedef ListUnique_<Arg1,Arg2> type;
676 ListUnique_Helper const list_unique_;
678 template <class Container, class Predicate, class Enable=void>
679 struct ListSort_ : euml_action<ListSort_<Container,Predicate,Enable> >
681 template <class Event,class FSM,class STATE >
682 struct state_action_result
686 template <class EVT,class FSM,class SourceState,class TargetState>
687 struct transition_action_result
691 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
693 template <class EVT,class FSM,class SourceState,class TargetState>
694 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
696 (Container()(evt,fsm,src,tgt)).sort();
698 template <class Event,class FSM,class STATE>
699 void operator()(Event const& evt,FSM& fsm,STATE& state )const
701 (Container()(evt,fsm,state)).sort();
704 template <class Container, class Predicate >
705 struct ListSort_<Container,Predicate,
706 typename ::boost::disable_if<typename ::boost::is_same<Predicate,void>::type >::type>
707 : euml_action<ListSort_<Container,Predicate> >
709 template <class Event,class FSM,class STATE >
710 struct state_action_result
714 template <class EVT,class FSM,class SourceState,class TargetState>
715 struct transition_action_result
719 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
721 template <class EVT,class FSM,class SourceState,class TargetState>
722 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
724 (Container()(evt,fsm,src,tgt)).sort(Predicate()(evt,fsm,src,tgt));
726 template <class Event,class FSM,class STATE>
727 void operator()(Event const& evt,FSM& fsm,STATE& state )const
729 (Container()(evt,fsm,state)).sort(Predicate()(evt,fsm,state));
732 struct list_sort_tag {};
733 struct ListSort_Helper: proto::extends< proto::terminal<list_sort_tag>::type, ListSort_Helper, boost::msm::sm_domain>
736 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
743 typedef ListSort_<Arg1,Arg2> type;
746 ListSort_Helper const list_sort_;
748 template <class Container>
749 struct Capacity_ : euml_action<Capacity_<Container> >
751 template <class Event,class FSM,class STATE >
752 struct state_action_result
754 typedef typename get_size_type<
755 typename ::boost::remove_reference<
756 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
758 template <class EVT,class FSM,class SourceState,class TargetState>
759 struct transition_action_result
761 typedef typename get_size_type<
762 typename ::boost::remove_reference<
763 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
765 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
767 template <class EVT,class FSM,class SourceState,class TargetState>
768 typename ::boost::enable_if<
769 typename ::boost::mpl::has_key<
770 typename Container::tag_type,action_tag>::type,
771 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
772 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
774 return (Container()(evt,fsm,src,tgt)).capacity();
776 template <class Event,class FSM,class STATE>
777 typename ::boost::enable_if<
778 typename ::boost::mpl::has_key<
779 typename Container::tag_type,state_action_tag>::type,
780 typename state_action_result<Event,FSM,STATE>::type >::type
781 operator()(Event const& evt,FSM& fsm,STATE& state )const
783 return (Container()(evt,fsm,state)).capacity();
786 struct capacity_tag {};
787 struct Capacity_Helper: proto::extends< proto::terminal<capacity_tag>::type, Capacity_Helper, boost::msm::sm_domain>
790 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
797 typedef Capacity_<Arg1> type;
800 Capacity_Helper const capacity_;
802 template <class Container>
803 struct Size_ : euml_action<Size_<Container> >
805 template <class Event,class FSM,class STATE >
806 struct state_action_result
808 typedef typename get_size_type<
809 typename ::boost::remove_reference<
810 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
812 template <class EVT,class FSM,class SourceState,class TargetState>
813 struct transition_action_result
815 typedef typename get_size_type<
816 typename ::boost::remove_reference<
817 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
819 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
821 template <class EVT,class FSM,class SourceState,class TargetState>
822 typename ::boost::enable_if<
823 typename ::boost::mpl::has_key<
824 typename Container::tag_type,action_tag>::type,
825 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
826 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
828 return (Container()(evt,fsm,src,tgt)).size();
830 template <class Event,class FSM,class STATE>
831 typename ::boost::enable_if<
832 typename ::boost::mpl::has_key<
833 typename Container::tag_type,state_action_tag>::type,
834 typename state_action_result<Event,FSM,STATE>::type >::type
835 operator()(Event const& evt,FSM& fsm,STATE& state )const
837 return (Container()(evt,fsm,state)).size();
841 struct Size_Helper: proto::extends< proto::terminal<size_tag>::type, Size_Helper, boost::msm::sm_domain>
844 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
851 typedef Size_<Arg1> type;
854 Size_Helper const size_;
856 template <class Container>
857 struct Max_Size_ : euml_action<Max_Size_<Container> >
859 template <class Event,class FSM,class STATE >
860 struct state_action_result
862 typedef typename get_size_type<
863 typename ::boost::remove_reference<
864 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
866 template <class EVT,class FSM,class SourceState,class TargetState>
867 struct transition_action_result
869 typedef typename get_size_type<
870 typename ::boost::remove_reference<
871 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
873 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
875 template <class EVT,class FSM,class SourceState,class TargetState>
876 typename ::boost::enable_if<
877 typename ::boost::mpl::has_key<
878 typename Container::tag_type,action_tag>::type,
879 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
880 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
882 return (Container()(evt,fsm,src,tgt)).max_size();
884 template <class Event,class FSM,class STATE>
885 typename ::boost::enable_if<
886 typename ::boost::mpl::has_key<
887 typename Container::tag_type,state_action_tag>::type,
888 typename state_action_result<Event,FSM,STATE>::type >::type
889 operator()(Event const& evt,FSM& fsm,STATE& state )const
891 return (Container()(evt,fsm,state)).max_size();
894 struct max_size_tag {};
895 struct Max_Size_Helper: proto::extends< proto::terminal<max_size_tag>::type, Max_Size_Helper, boost::msm::sm_domain>
898 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
905 typedef Max_Size_<Arg1> type;
908 Max_Size_Helper const max_size_;
910 template <class Container, class Value>
911 struct Reserve_ : euml_action<Reserve_<Container,Value> >
913 template <class Event,class FSM,class STATE >
914 struct state_action_result
918 template <class EVT,class FSM,class SourceState,class TargetState>
919 struct transition_action_result
923 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
925 template <class EVT,class FSM,class SourceState,class TargetState>
926 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
928 (Container()(evt,fsm,src,tgt)).reserve(Value()(evt,fsm,src,tgt));
930 template <class Event,class FSM,class STATE>
931 void operator()(Event const& evt,FSM& fsm,STATE& state )const
933 (Container()(evt,fsm,state)).reserve(Value()(evt,fsm,state));
936 struct reserve_tag {};
937 struct Reserve_Helper: proto::extends< proto::terminal<reserve_tag>::type, Reserve_Helper, boost::msm::sm_domain>
940 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
947 typedef Reserve_<Arg1,Arg2> type;
950 Reserve_Helper const reserve_;
952 template <class Container, class Num, class Value ,class Enable=void >
953 struct Resize_ : euml_action<Resize_<Container,Num,Value> >
955 template <class Event,class FSM,class STATE >
956 struct state_action_result
960 template <class EVT,class FSM,class SourceState,class TargetState>
961 struct transition_action_result
965 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
967 template <class EVT,class FSM,class SourceState,class TargetState>
968 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
970 (Container()(evt,fsm,src,tgt)).resize(Num()(evt,fsm,src,tgt));
972 template <class Event,class FSM,class STATE>
973 void operator()(Event const& evt,FSM& fsm,STATE& state )const
975 (Container()(evt,fsm,state)).resize(Num()(evt,fsm,state));
978 template <class Container, class Num , class Value >
979 struct Resize_<Container,Num,Value,typename ::boost::disable_if<typename ::boost::is_same<Value,void>::type >::type>
980 : euml_action<Resize_<Container,Num,Value> >
982 template <class Event,class FSM,class STATE >
983 struct state_action_result
987 template <class EVT,class FSM,class SourceState,class TargetState>
988 struct transition_action_result
992 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
994 template <class EVT,class FSM,class SourceState,class TargetState>
995 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
997 (Container()(evt,fsm,src,tgt)).resize(Num()(evt,fsm,src,tgt),Value()(evt,fsm,src,tgt));
999 template <class Event,class FSM,class STATE>
1000 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1002 (Container()(evt,fsm,state)).resize(Num()(evt,fsm,state),Value()(evt,fsm,state));
1005 struct resize_tag {};
1006 struct Resize_Helper: proto::extends< proto::terminal<resize_tag>::type, Resize_Helper, boost::msm::sm_domain>
1009 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1016 typedef Resize_<Arg1,Arg2,Arg3> type;
1019 Resize_Helper const resize_;
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> >
1025 template <class Event,class FSM,class STATE >
1026 struct state_action_result
1030 template <class EVT,class FSM,class SourceState,class TargetState>
1031 struct transition_action_result
1035 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1037 template <class EVT,class FSM,class SourceState,class TargetState>
1038 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1040 (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
1041 Param3()(evt,fsm,src,tgt));
1043 template <class Event,class FSM,class STATE>
1044 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1046 (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1047 Param3()(evt,fsm,state));
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> >
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
1060 typedef typename get_iterator<
1061 typename ::boost::remove_reference<
1062 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
1064 template <class EVT,class FSM,class SourceState,class TargetState>
1065 struct transition_action_result
1067 typedef typename get_iterator<
1068 typename ::boost::remove_reference<
1069 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
1071 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1085 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1087 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1089 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
1102 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1104 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1106 (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
1121 typename state_action_result<Event,FSM,STATE>::type
1123 operator()(Event const& evt,FSM& fsm,STATE& state )const
1125 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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
1138 typename state_action_result<Event,FSM,STATE>::type
1140 operator()(Event const& evt,FSM& fsm,STATE& state )const
1142 (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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> >
1151 template <class Event,class FSM,class STATE >
1152 struct state_action_result
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;
1159 template <class EVT,class FSM,class SourceState,class TargetState>
1160 struct transition_action_result
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;
1167 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1176 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt));
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
1185 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state));
1188 struct insert_tag {};
1189 struct Insert_Helper: proto::extends< proto::terminal<insert_tag>::type, Insert_Helper, boost::msm::sm_domain>
1192 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1199 typedef Insert_<Arg1,Arg2,Arg3,Arg4> type;
1202 Insert_Helper const insert_;
1204 template <class Container1,class Container2>
1205 struct Swap_ : euml_action<Swap_<Container1,Container2> >
1207 template <class Event,class FSM,class STATE >
1208 struct state_action_result
1212 template <class EVT,class FSM,class SourceState,class TargetState>
1213 struct transition_action_result
1217 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1219 template <class EVT,class FSM,class SourceState,class TargetState>
1220 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1222 (Container1()(evt,fsm,src,tgt)).swap(Container2()(evt,fsm,src,tgt));
1224 template <class Event,class FSM,class STATE>
1225 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1227 (Container1()(evt,fsm,state)).swap(Container2()(evt,fsm,state));
1231 struct Swap_Helper: proto::extends< proto::terminal<swap_tag>::type, Swap_Helper, boost::msm::sm_domain>
1234 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1241 typedef Swap_<Arg1,Arg2> type;
1244 Swap_Helper const swap_;
1246 template <class Container, class Iterator1, class Iterator2 ,class Enable=void >
1247 struct Erase_ : euml_action<Erase_<Container,Iterator1,Iterator2> >
1249 template <class Event,class FSM,class STATE >
1250 struct state_action_result
1252 typedef typename get_result_type2<Iterator1,Event,FSM,STATE>::type type;
1254 template <class EVT,class FSM,class SourceState,class TargetState>
1255 struct transition_action_result
1257 typedef typename get_result_type<Iterator1,EVT,FSM,SourceState,TargetState>::type type;
1259 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1268 return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt));
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
1277 return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state));
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> >
1285 template <class Event,class FSM,class STATE >
1286 struct state_action_result
1288 typedef typename get_result_type2<Iterator1,Event,FSM,STATE>::type type;
1290 template <class EVT,class FSM,class SourceState,class TargetState>
1291 struct transition_action_result
1293 typedef typename get_result_type<Iterator1,EVT,FSM,SourceState,TargetState>::type type;
1295 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1304 return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt),Iterator2()(evt,fsm,src,tgt));
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
1313 return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state),Iterator2()(evt,fsm,state));
1316 struct erase_tag {};
1317 struct Erase_Helper: proto::extends< proto::terminal<erase_tag>::type, Erase_Helper, boost::msm::sm_domain>
1320 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1327 typedef Erase_<Arg1,Arg2,Arg3> type;
1330 Erase_Helper const erase_;
1332 template <class Container>
1333 struct Empty_ : euml_action<Empty_<Container> >
1335 template <class Event,class FSM,class STATE >
1336 struct state_action_result
1340 template <class EVT,class FSM,class SourceState,class TargetState>
1341 struct transition_action_result
1345 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1347 template <class EVT,class FSM,class SourceState,class TargetState>
1348 bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1350 return (Container()(evt,fsm,src,tgt)).empty();
1352 template <class Event,class FSM,class STATE>
1353 bool operator()(Event const& evt,FSM& fsm,STATE& state )const
1355 return (Container()(evt,fsm,state)).empty();
1358 struct empty_tag {};
1359 struct Empty_Helper: proto::extends< proto::terminal<empty_tag>::type, Empty_Helper, boost::msm::sm_domain>
1362 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1369 typedef Empty_<Arg1> type;
1372 Empty_Helper const empty_;
1374 template <class Container,class Element>
1375 struct ListRemove_ : euml_action<ListRemove_<Container,Element> >
1377 template <class Event,class FSM,class STATE >
1378 struct state_action_result
1382 template <class EVT,class FSM,class SourceState,class TargetState>
1383 struct transition_action_result
1387 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1389 template <class EVT,class FSM,class SourceState,class TargetState>
1390 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1392 (Container()(evt,fsm,src,tgt)).remove(Element()(evt,fsm,src,tgt));
1394 template <class Event,class FSM,class STATE>
1395 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1397 (Container()(evt,fsm,state)).remove(Element()(evt,fsm,state));
1400 struct list_remove_tag {};
1401 struct ListRemove_Helper: proto::extends< proto::terminal<list_remove_tag>::type, ListRemove_Helper, boost::msm::sm_domain>
1403 ListRemove_Helper(){}
1404 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1411 typedef ListRemove_<Arg1,Arg2> type;
1414 ListRemove_Helper const list_remove_;
1416 template <class Container,class Element>
1417 struct ListRemove_If_ : euml_action<ListRemove_If_<Container,Element> >
1419 template <class Event,class FSM,class STATE >
1420 struct state_action_result
1424 template <class EVT,class FSM,class SourceState,class TargetState>
1425 struct transition_action_result
1429 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1431 template <class EVT,class FSM,class SourceState,class TargetState>
1432 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1434 (Container()(evt,fsm,src,tgt)).remove_if(Element()(evt,fsm,src,tgt));
1436 template <class Event,class FSM,class STATE>
1437 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1439 (Container()(evt,fsm,state)).remove_if(Element()(evt,fsm,state));
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>
1445 ListRemove_If_Helper(){}
1446 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1453 typedef ListRemove_If_<Arg1,Arg2> type;
1456 ListRemove_If_Helper const list_remove_if_;
1458 template <class Container, class ToMerge, class Predicate, class Enable=void>
1459 struct ListMerge_ : euml_action<ListMerge_<Container,ToMerge,Predicate,Enable> >
1461 template <class Event,class FSM,class STATE >
1462 struct state_action_result
1466 template <class EVT,class FSM,class SourceState,class TargetState>
1467 struct transition_action_result
1471 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1473 template <class EVT,class FSM,class SourceState,class TargetState>
1474 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1476 (Container()(evt,fsm,src,tgt)).merge(ToMerge()(evt,fsm,src,tgt));
1478 template <class Event,class FSM,class STATE>
1479 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1481 (Container()(evt,fsm,state)).merge(ToMerge()(evt,fsm,state));
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> >
1489 template <class Event,class FSM,class STATE >
1490 struct state_action_result
1494 template <class EVT,class FSM,class SourceState,class TargetState>
1495 struct transition_action_result
1499 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1501 template <class EVT,class FSM,class SourceState,class TargetState>
1502 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1504 (Container()(evt,fsm,src,tgt)).merge(ToMerge()(evt,fsm,src,tgt),Predicate()(evt,fsm,src,tgt));
1506 template <class Event,class FSM,class STATE>
1507 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1509 (Container()(evt,fsm,state)).merge(ToMerge()(evt,fsm,state),Predicate()(evt,fsm,state));
1512 struct list_merge_tag {};
1513 struct ListMerge_Helper: proto::extends< proto::terminal<list_merge_tag>::type, ListMerge_Helper, boost::msm::sm_domain>
1515 ListMerge_Helper(){}
1516 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1523 typedef ListMerge_<Arg1,Arg2,Arg3> type;
1526 ListMerge_Helper const list_merge_;
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> >
1531 template <class Event,class FSM,class STATE >
1532 struct state_action_result
1536 template <class EVT,class FSM,class SourceState,class TargetState>
1537 struct transition_action_result
1541 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1550 return (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
1559 return (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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> >
1570 template <class Event,class FSM,class STATE >
1571 struct state_action_result
1575 template <class EVT,class FSM,class SourceState,class TargetState>
1576 struct transition_action_result
1580 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1582 template <class EVT,class FSM,class SourceState,class TargetState>
1583 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1585 (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
1586 Param3()(evt,fsm,src,tgt));
1588 template <class Event,class FSM,class STATE>
1589 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1591 (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1592 Param3()(evt,fsm,state));
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> >
1600 template <class Event,class FSM,class STATE >
1601 struct state_action_result
1605 template <class EVT,class FSM,class SourceState,class TargetState>
1606 struct transition_action_result
1610 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1612 template <class EVT,class FSM,class SourceState,class TargetState>
1613 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
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));
1618 template <class Event,class FSM,class STATE>
1619 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1621 (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1622 Param3()(evt,fsm,state),Param4()(evt,fsm,state));
1625 struct splice_tag {};
1626 struct Splice_Helper: proto::extends< proto::terminal<splice_tag>::type, Splice_Helper, boost::msm::sm_domain>
1629 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1636 typedef Splice_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
1639 Splice_Helper const splice_;
1641 //template <class Container, class Param1, class Param2, class Param3, class Enable=void >
1642 //struct StringFind_ : euml_action<StringFind_<Container,Param1,Param2,Param3,Enable> >
1645 template <class Container,class Param1, class Param2, class Param3>
1646 struct StringFind_ : euml_action<StringFind_<Container,Param1,Param2,Param3> >
1648 template <class Event,class FSM,class STATE >
1649 struct state_action_result
1651 typedef typename remove_reference<
1652 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1654 template <class EVT,class FSM,class SourceState,class TargetState>
1655 struct transition_action_result
1657 typedef typename remove_reference<
1658 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1660 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1666 return (Container()(evt,fsm,src,tgt)).
1667 find(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
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
1673 return (Container()(evt,fsm,state)).
1674 find(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1678 template <class Container,class Param1>
1679 struct StringFind_ < Container,Param1,void,void>
1680 : euml_action<StringFind_<Container,Param1,void,void> >
1683 template <class Event,class FSM,class STATE >
1684 struct state_action_result
1686 typedef typename remove_reference<
1687 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1689 template <class EVT,class FSM,class SourceState,class TargetState>
1690 struct transition_action_result
1692 typedef typename remove_reference<
1693 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1695 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1701 return (Container()(evt,fsm,src,tgt)).find(Param1()(evt,fsm,src,tgt));
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
1707 return (Container()(evt,fsm,state)).find(Param1()(evt,fsm,state));
1711 template <class Container,class Param1, class Param2>
1712 struct StringFind_ <Container,Param1,Param2,void>
1713 : euml_action<StringFind_<Container,Param1,Param2,void> >
1715 template <class Event,class FSM,class STATE >
1716 struct state_action_result
1718 typedef typename remove_reference<
1719 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1721 template <class EVT,class FSM,class SourceState,class TargetState>
1722 struct transition_action_result
1724 typedef typename remove_reference<
1725 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1727 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1733 return (Container()(evt,fsm,src,tgt)).find(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
1739 return (Container()(evt,fsm,state)).find(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1743 struct string_find_tag {};
1744 struct StringFind_Helper: proto::extends< proto::terminal<string_find_tag>::type, StringFind_Helper, boost::msm::sm_domain>
1746 StringFind_Helper(){}
1747 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1754 typedef StringFind_<Arg1,Arg2,Arg3,Arg4> type;
1757 StringFind_Helper const string_find_;
1759 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
1760 struct StringRFind_ : euml_action<StringRFind_<Container,Param1,Param2,Param3,Enable> >
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
1771 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1774 template <class Event,class FSM,class STATE >
1775 struct state_action_result
1777 typedef typename remove_reference<
1778 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1780 template <class EVT,class FSM,class SourceState,class TargetState>
1781 struct transition_action_result
1783 typedef typename remove_reference<
1784 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1786 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1792 return (Container()(evt,fsm,src,tgt)).rfind(Param1()(evt,fsm,src,tgt));
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
1798 return (Container()(evt,fsm,state)).rfind(Param1()(evt,fsm,state));
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
1814 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1816 template <class Event,class FSM,class STATE >
1817 struct state_action_result
1819 typedef typename remove_reference<
1820 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1822 template <class EVT,class FSM,class SourceState,class TargetState>
1823 struct transition_action_result
1825 typedef typename remove_reference<
1826 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1828 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1834 return (Container()(evt,fsm,src,tgt)).rfind(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
1840 return (Container()(evt,fsm,state)).rfind(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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
1851 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1853 template <class Event,class FSM,class STATE >
1854 struct state_action_result
1856 typedef typename remove_reference<
1857 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1859 template <class EVT,class FSM,class SourceState,class TargetState>
1860 struct transition_action_result
1862 typedef typename remove_reference<
1863 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1865 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1871 return (Container()(evt,fsm,src,tgt)).
1872 rfind(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
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
1878 return (Container()(evt,fsm,state)).
1879 rfind(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1883 struct string_rfind_tag {};
1884 struct StringRFind_Helper: proto::extends< proto::terminal<string_rfind_tag>::type, StringRFind_Helper, boost::msm::sm_domain>
1886 StringRFind_Helper(){}
1887 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1894 typedef StringRFind_<Arg1,Arg2,Arg3,Arg4> type;
1897 StringRFind_Helper const string_rfind_;
1899 template <class Container,class Param1, class Param2, class Param3>
1900 struct StringFindFirstOf_ : euml_action<StringFindFirstOf_<Container,Param1,Param2,Param3> >
1902 template <class Event,class FSM,class STATE >
1903 struct state_action_result
1905 typedef typename remove_reference<
1906 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1908 template <class EVT,class FSM,class SourceState,class TargetState>
1909 struct transition_action_result
1911 typedef typename remove_reference<
1912 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1914 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
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));
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
1927 return (Container()(evt,fsm,state)).
1928 find_first_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1931 template <class Container,class Param1>
1932 struct StringFindFirstOf_ <Container,Param1,void,void>
1933 : euml_action<StringFindFirstOf_<Container,Param1,void,void> >
1935 template <class Event,class FSM,class STATE >
1936 struct state_action_result
1938 typedef typename remove_reference<
1939 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1941 template <class EVT,class FSM,class SourceState,class TargetState>
1942 struct transition_action_result
1944 typedef typename remove_reference<
1945 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1947 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1953 return (Container()(evt,fsm,src,tgt)).find_first_of(Param1()(evt,fsm,src,tgt));
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
1959 return (Container()(evt,fsm,state)).find_first_of(Param1()(evt,fsm,state));
1963 template <class Container,class Param1, class Param2>
1964 struct StringFindFirstOf_ <Container,Param1,Param2,void>
1965 : euml_action<StringFindFirstOf_<Container,Param1,Param2,void> >
1967 template <class Event,class FSM,class STATE >
1968 struct state_action_result
1970 typedef typename remove_reference<
1971 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1973 template <class EVT,class FSM,class SourceState,class TargetState>
1974 struct transition_action_result
1976 typedef typename remove_reference<
1977 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1979 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
1985 return (Container()(evt,fsm,src,tgt)).find_first_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
1991 return (Container()(evt,fsm,state)).find_first_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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>
1999 StringFindFirstOf_Helper(){}
2000 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2007 typedef StringFindFirstOf_<Arg1,Arg2,Arg3,Arg4> type;
2010 StringFindFirstOf_Helper const string_find_first_of_;
2012 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2013 struct StringFindFirstNotOf_ : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3,Enable> >
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
2024 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2027 template <class Event,class FSM,class STATE >
2028 struct state_action_result
2030 typedef typename remove_reference<
2031 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2033 template <class EVT,class FSM,class SourceState,class TargetState>
2034 struct transition_action_result
2036 typedef typename remove_reference<
2037 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2039 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2045 return (Container()(evt,fsm,src,tgt)).find_first_not_of(Param1()(evt,fsm,src,tgt));
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
2051 return (Container()(evt,fsm,state)).find_first_not_of(Param1()(evt,fsm,state));
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
2067 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2069 template <class Event,class FSM,class STATE >
2070 struct state_action_result
2072 typedef typename remove_reference<
2073 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2075 template <class EVT,class FSM,class SourceState,class TargetState>
2076 struct transition_action_result
2078 typedef typename remove_reference<
2079 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2081 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2087 return (Container()(evt,fsm,src,tgt)).find_first_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
2093 return (Container()(evt,fsm,state)).find_first_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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
2104 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2106 template <class Event,class FSM,class STATE >
2107 struct state_action_result
2109 typedef typename remove_reference<
2110 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2112 template <class EVT,class FSM,class SourceState,class TargetState>
2113 struct transition_action_result
2115 typedef typename remove_reference<
2116 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2118 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
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));
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
2131 return (Container()(evt,fsm,state)).
2132 find_first_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
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>
2140 StringFindFirstNotOf_Helper(){}
2141 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2148 typedef StringFindFirstNotOf_<Arg1,Arg2,Arg3,Arg4> type;
2151 StringFindFirstNotOf_Helper const string_find_first_not_of_;
2153 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2154 struct StringFindLastOf_ : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3,Enable> >
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
2165 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2168 template <class Event,class FSM,class STATE >
2169 struct state_action_result
2171 typedef typename remove_reference<
2172 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2174 template <class EVT,class FSM,class SourceState,class TargetState>
2175 struct transition_action_result
2177 typedef typename remove_reference<
2178 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2180 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2186 return (Container()(evt,fsm,src,tgt)).find_last_of(Param1()(evt,fsm,src,tgt));
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
2192 return (Container()(evt,fsm,state)).find_last_of(Param1()(evt,fsm,state));
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
2208 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2210 template <class Event,class FSM,class STATE >
2211 struct state_action_result
2213 typedef typename remove_reference<
2214 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2216 template <class EVT,class FSM,class SourceState,class TargetState>
2217 struct transition_action_result
2219 typedef typename remove_reference<
2220 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2222 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2228 return (Container()(evt,fsm,src,tgt)).find_last_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
2234 return (Container()(evt,fsm,state)).find_last_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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
2245 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2247 template <class Event,class FSM,class STATE >
2248 struct state_action_result
2250 typedef typename remove_reference<
2251 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2253 template <class EVT,class FSM,class SourceState,class TargetState>
2254 struct transition_action_result
2256 typedef typename remove_reference<
2257 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2259 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
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));
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
2272 return (Container()(evt,fsm,state)).
2273 find_last_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
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>
2281 StringFindLastOf_Helper(){}
2282 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2289 typedef StringFindLastOf_<Arg1,Arg2,Arg3,Arg4> type;
2292 StringFindLastOf_Helper const string_find_last_of_;
2294 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2295 struct StringFindLastNotOf_ : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3,Enable> >
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
2306 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2309 template <class Event,class FSM,class STATE >
2310 struct state_action_result
2312 typedef typename remove_reference<
2313 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2315 template <class EVT,class FSM,class SourceState,class TargetState>
2316 struct transition_action_result
2318 typedef typename remove_reference<
2319 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2321 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2327 return (Container()(evt,fsm,src,tgt)).find_last_not_of(Param1()(evt,fsm,src,tgt));
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
2333 return (Container()(evt,fsm,state)).find_last_not_of(Param1()(evt,fsm,state));
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
2349 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2351 template <class Event,class FSM,class STATE >
2352 struct state_action_result
2354 typedef typename remove_reference<
2355 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2357 template <class EVT,class FSM,class SourceState,class TargetState>
2358 struct transition_action_result
2360 typedef typename remove_reference<
2361 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2363 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2369 return (Container()(evt,fsm,src,tgt)).find_last_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
2375 return (Container()(evt,fsm,state)).find_last_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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
2386 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2388 template <class Event,class FSM,class STATE >
2389 struct state_action_result
2391 typedef typename remove_reference<
2392 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2394 template <class EVT,class FSM,class SourceState,class TargetState>
2395 struct transition_action_result
2397 typedef typename remove_reference<
2398 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2400 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
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));
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
2413 return (Container()(evt,fsm,state)).
2414 find_last_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
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>
2422 StringFindLastNotOf_Helper(){}
2423 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2430 typedef StringFindLastNotOf_<Arg1,Arg2,Arg3,Arg4> type;
2433 StringFindLastNotOf_Helper const string_find_last_not_of_;
2435 template <class Container>
2436 struct Npos_ : euml_action<Npos_<Container> >
2439 template <class Event,class FSM,class STATE >
2440 struct state_action_result
2442 typedef typename Container::size_type type;
2444 template <class EVT,class FSM,class SourceState,class TargetState>
2445 struct transition_action_result
2447 typedef typename Container::size_type type;
2449 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2455 return Container::npos;
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
2461 return Container::npos;
2465 // version for 2 parameters
2466 template <class Container, class Param1, class Param2>
2467 struct Associative_Erase_ : euml_action<Associative_Erase_<Container,Param1,Param2> >
2469 template <class Event,class FSM,class STATE >
2470 struct state_action_result
2474 template <class EVT,class FSM,class SourceState,class TargetState>
2475 struct transition_action_result
2479 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2488 (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
2497 (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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> >
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
2510 typedef typename get_size_type<
2511 typename ::boost::remove_reference<
2512 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
2514 template <class EVT,class FSM,class SourceState,class TargetState>
2515 struct transition_action_result
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;
2521 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2535 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2537 (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
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
2552 operator()(Event const& evt,FSM& fsm,STATE& state )const
2554 (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
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
2569 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2571 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2573 return (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
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
2588 typename state_action_result<Event,FSM,STATE>::type
2590 operator()(Event const& evt,FSM& fsm,STATE& state )const
2592 return (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
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>
2599 Associative_Erase_Helper(){}
2600 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2607 typedef Associative_Erase_<Arg1,Arg2,Arg3> type;
2610 Associative_Erase_Helper const associative_erase_;
2613 template <class T, class Param>
2614 struct Associative_Find_ : euml_action<Associative_Find_<T,Param> >
2616 template <class Event,class FSM,class STATE >
2617 struct state_action_result
2619 typedef typename get_iterator<
2620 typename ::boost::remove_reference<
2621 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2623 template <class EVT,class FSM,class SourceState,class TargetState>
2624 struct transition_action_result
2626 typedef typename get_iterator<
2627 typename ::boost::remove_reference<
2628 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2630 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2639 return (T()(evt,fsm,src,tgt)).find(Param()(evt,fsm,src,tgt));
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
2648 return (T()(evt,fsm,state)).find(Param()(evt,fsm,state));
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>
2655 Associative_Find_Helper(){}
2656 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2663 typedef Associative_Find_<Arg1,Arg2> type;
2666 Associative_Find_Helper const associative_find_;
2668 template <class Container,class Param>
2669 struct AssociativeCount_ : euml_action<AssociativeCount_<Container,Param> >
2671 template <class Event,class FSM,class STATE >
2672 struct state_action_result
2674 typedef typename get_size_type<
2675 typename ::boost::remove_reference<
2676 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
2678 template <class EVT,class FSM,class SourceState,class TargetState>
2679 struct transition_action_result
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;
2685 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2694 return (Container()(evt,fsm,src,tgt)).count(Param()(evt,fsm,src,tgt));
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
2703 return (Container()(evt,fsm,state)).count(Param()(evt,fsm,state));
2706 struct associative_count_tag {};
2707 struct AssociativeCount_Helper: proto::extends< proto::terminal<associative_count_tag>::type, AssociativeCount_Helper, boost::msm::sm_domain>
2709 AssociativeCount_Helper(){}
2710 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2717 typedef AssociativeCount_<Arg1,Arg2> type;
2720 AssociativeCount_Helper const associative_count_;
2722 template <class T, class Param>
2723 struct Associative_Lower_Bound_ : euml_action<Associative_Lower_Bound_<T,Param> >
2725 template <class Event,class FSM,class STATE >
2726 struct state_action_result
2728 typedef typename get_iterator<
2729 typename ::boost::remove_reference<
2730 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2732 template <class EVT,class FSM,class SourceState,class TargetState>
2733 struct transition_action_result
2735 typedef typename get_iterator<
2736 typename ::boost::remove_reference<
2737 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2739 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2748 return (T()(evt,fsm,src,tgt)).lower_bound(Param()(evt,fsm,src,tgt));
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
2757 return (T()(evt,fsm,state)).lower_bound(Param()(evt,fsm,state));
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>
2765 Associative_Lower_Bound_Helper(){}
2766 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2773 typedef Associative_Lower_Bound_<Arg1,Arg2> type;
2776 Associative_Lower_Bound_Helper const associative_lower_bound_;
2778 template <class T, class Param>
2779 struct Associative_Upper_Bound_ : euml_action<Associative_Upper_Bound_<T,Param> >
2781 template <class Event,class FSM,class STATE >
2782 struct state_action_result
2784 typedef typename get_iterator<
2785 typename ::boost::remove_reference<
2786 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2788 template <class EVT,class FSM,class SourceState,class TargetState>
2789 struct transition_action_result
2791 typedef typename get_iterator<
2792 typename ::boost::remove_reference<
2793 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2795 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2804 return (T()(evt,fsm,src,tgt)).upper_bound(Param()(evt,fsm,src,tgt));
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
2813 return (T()(evt,fsm,state)).upper_bound(Param()(evt,fsm,state));
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>
2821 Associative_Upper_Bound_Helper(){}
2822 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2829 typedef Associative_Upper_Bound_<Arg1,Arg2> type;
2832 Associative_Upper_Bound_Helper const associative_upper_bound_;
2835 struct First_ : euml_action<First_<T> >
2837 template <class Event,class FSM,class STATE >
2838 struct state_action_result
2840 typedef typename get_first_type<
2841 typename ::boost::remove_reference<
2842 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2844 template <class EVT,class FSM,class SourceState,class TargetState>
2845 struct transition_action_result
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;
2851 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2860 return (T()(evt,fsm,src,tgt)).first;
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
2869 return (T()(evt,fsm,state)).first;
2873 struct first_tag {};
2874 struct First_Helper: proto::extends< proto::terminal<first_tag>::type, First_Helper, boost::msm::sm_domain>
2877 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2884 typedef First_<Arg1> type;
2887 First_Helper const first_;
2890 struct Second_ : euml_action<Second_<T> >
2892 template <class Event,class FSM,class STATE >
2893 struct state_action_result
2895 typedef typename get_second_type<
2896 typename ::boost::remove_reference<
2897 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2899 template <class EVT,class FSM,class SourceState,class TargetState>
2900 struct transition_action_result
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;
2906 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2915 return (T()(evt,fsm,src,tgt)).second;
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
2924 return (T()(evt,fsm,state)).second;
2928 struct second_tag {};
2929 struct Second_Helper: proto::extends< proto::terminal<second_tag>::type, Second_Helper, boost::msm::sm_domain>
2932 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2939 typedef Second_<Arg1> type;
2942 Second_Helper const second_;
2944 template <class T, class Param>
2945 struct Associative_Equal_Range_ : euml_action<Associative_Equal_Range_<T,Param> >
2947 template <class Event,class FSM,class STATE >
2948 struct state_action_result
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;
2958 template <class EVT,class FSM,class SourceState,class TargetState>
2959 struct transition_action_result
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;
2969 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
2978 return (T()(evt,fsm,src,tgt)).equal_range(Param()(evt,fsm,src,tgt));
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
2987 return (T()(evt,fsm,state)).equal_range(Param()(evt,fsm,state));
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>
2995 Associative_Equal_Range_Helper(){}
2996 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3003 typedef Associative_Equal_Range_<Arg1,Arg2> type;
3006 Associative_Equal_Range_Helper const associative_equal_range_;
3008 template <class Container,class Param1, class Param2>
3009 struct Substr_ : euml_action<Substr_<Container,Param1,Param2> >
3011 template <class Event,class FSM,class STATE >
3012 struct state_action_result
3014 typedef typename remove_reference<
3015 typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3017 template <class EVT,class FSM,class SourceState,class TargetState>
3018 struct transition_action_result
3020 typedef typename remove_reference<
3021 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3023 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3029 return (Container()(evt,fsm,src,tgt)).
3030 substr(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
3036 return (Container()(evt,fsm,state)).
3037 substr(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3040 template <class Container>
3041 struct Substr_ <Container,void,void>
3042 : euml_action<Substr_<Container,void,void> >
3045 template <class Event,class FSM,class STATE >
3046 struct state_action_result
3048 typedef typename remove_reference<
3049 typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3051 template <class EVT,class FSM,class SourceState,class TargetState>
3052 struct transition_action_result
3054 typedef typename remove_reference<
3055 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3057 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3063 return (Container()(evt,fsm,src,tgt)).substr();
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
3069 return (Container()(evt,fsm,state)).substr();
3073 template <class Container,class Param1>
3074 struct Substr_ < Container,Param1,void>
3075 : euml_action<Substr_<Container,Param1,void> >
3077 template <class Event,class FSM,class STATE >
3078 struct state_action_result
3080 typedef typename remove_reference<
3081 typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3083 template <class EVT,class FSM,class SourceState,class TargetState>
3084 struct transition_action_result
3086 typedef typename remove_reference<
3087 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3089 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3095 return (Container()(evt,fsm,src,tgt)).substr(Param1()(evt,fsm,src,tgt));
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
3101 return (Container()(evt,fsm,state)).substr(Param1()(evt,fsm,state));
3104 struct substr_tag {};
3105 struct Substr_Helper: proto::extends< proto::terminal<substr_tag>::type, Substr_Helper, boost::msm::sm_domain>
3108 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3115 typedef Substr_<Arg1,Arg2,Arg3> type;
3118 Substr_Helper const substr_;
3120 template <class Container, class Param1, class Param2, class Param3, class Param4 >
3121 struct StringCompare_ : euml_action<StringCompare_<Container,Param1,Param2,Param3,Param4> >
3123 template <class Event,class FSM,class STATE >
3124 struct state_action_result
3128 template <class EVT,class FSM,class SourceState,class TargetState>
3129 struct transition_action_result
3133 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
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));
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
3152 return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3153 Param3()(evt,fsm,state),Param4()(evt,fsm,state));
3156 template <class Container, class Param1 >
3157 struct StringCompare_<Container,Param1,void,void,void>
3158 : euml_action<StringCompare_<Container,Param1,void,void,void> >
3160 template <class Event,class FSM,class STATE >
3161 struct state_action_result
3165 template <class EVT,class FSM,class SourceState,class TargetState>
3166 struct transition_action_result
3170 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3179 return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt));
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
3188 return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state));
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> >
3196 template <class Event,class FSM,class STATE >
3197 struct state_action_result
3201 template <class EVT,class FSM,class SourceState,class TargetState>
3202 struct transition_action_result
3206 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3215 return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
3224 return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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> >
3232 template <class Event,class FSM,class STATE >
3233 struct state_action_result
3237 template <class EVT,class FSM,class SourceState,class TargetState>
3238 struct transition_action_result
3242 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3251 return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3252 Param3()(evt,fsm,src,tgt));
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
3261 return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3262 Param3()(evt,fsm,state));
3266 struct string_compare_tag {};
3267 struct StringCompare_Helper: proto::extends< proto::terminal<string_compare_tag>::type, StringCompare_Helper, boost::msm::sm_domain>
3269 StringCompare_Helper(){}
3270 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3277 typedef StringCompare_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3280 StringCompare_Helper const string_compare_;
3282 template <class Container, class Param1, class Param2, class Param3 >
3283 struct Append_ : euml_action<Append_<Container,Param1,Param2,Param3> >
3285 template <class Event,class FSM,class STATE >
3286 struct state_action_result
3288 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3290 template <class EVT,class FSM,class SourceState,class TargetState>
3291 struct transition_action_result
3293 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3295 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3304 return (Container()(evt,fsm,src,tgt)).append (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3305 Param3()(evt,fsm,src,tgt));
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
3314 return (Container()(evt,fsm,state)).append (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3315 Param3()(evt,fsm,state));
3318 template <class Container, class Param1>
3319 struct Append_<Container,Param1,void,void>
3320 : euml_action<Append_<Container,Param1,void,void> >
3322 template <class Event,class FSM,class STATE >
3323 struct state_action_result
3325 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3327 template <class EVT,class FSM,class SourceState,class TargetState>
3328 struct transition_action_result
3330 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3332 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3341 return (Container()(evt,fsm,src,tgt)).append(Param1()(evt,fsm,src,tgt));
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
3350 return (Container()(evt,fsm,state)).append(Param1()(evt,fsm,state));
3354 template <class Container, class Param1, class Param2 >
3355 struct Append_<Container,Param1,Param2,void>
3356 : euml_action<Append_<Container,Param1,Param2,void> >
3358 template <class Event,class FSM,class STATE >
3359 struct state_action_result
3361 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3363 template <class EVT,class FSM,class SourceState,class TargetState>
3364 struct transition_action_result
3366 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3368 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3377 return (Container()(evt,fsm,src,tgt)).append(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
3386 return (Container()(evt,fsm,state)).append(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3390 struct append_tag {};
3391 struct Append_Helper: proto::extends< proto::terminal<append_tag>::type, Append_Helper, boost::msm::sm_domain>
3394 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3401 typedef Append_<Arg1,Arg2,Arg3,Arg4> type;
3404 Append_Helper const append_;
3406 template <class Container, class Param1, class Param2, class Param3, class Param4 >
3407 struct StringInsert_ : euml_action<StringInsert_<Container,Param1,Param2,Param3,Param4> >
3409 template <class Event,class FSM,class STATE >
3410 struct state_action_result
3412 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3414 template <class EVT,class FSM,class SourceState,class TargetState>
3415 struct transition_action_result
3417 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3419 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
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));
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
3438 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3439 Param3()(evt,fsm,state),Param4()(evt,fsm,state));
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> >
3446 template <class Event,class FSM,class STATE >
3447 struct state_action_result
3449 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3451 template <class EVT,class FSM,class SourceState,class TargetState>
3452 struct transition_action_result
3454 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3456 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3465 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
3474 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
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> >
3481 template <class Event,class FSM,class STATE >
3482 struct state_action_result
3484 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3486 template <class EVT,class FSM,class SourceState,class TargetState>
3487 struct transition_action_result
3489 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3491 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3500 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3501 Param3()(evt,fsm,src,tgt));
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
3510 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3511 Param3()(evt,fsm,state));
3515 struct string_insert_tag {};
3516 struct StringInsert_Helper: proto::extends< proto::terminal<string_insert_tag>::type, StringInsert_Helper, boost::msm::sm_domain>
3518 StringInsert_Helper(){}
3519 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3526 typedef StringInsert_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3529 StringInsert_Helper const string_insert_;
3531 template <class Container,class Param1, class Param2>
3532 struct StringErase_ : euml_action<StringErase_<Container,Param1,Param2> >
3534 template <class Event,class FSM,class STATE >
3535 struct state_action_result
3537 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3539 template <class EVT,class FSM,class SourceState,class TargetState>
3540 struct transition_action_result
3542 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3544 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3550 return (Container()(evt,fsm,src,tgt)).
3551 erase(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
3557 return (Container()(evt,fsm,state)).
3558 erase(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3561 template <class Container>
3562 struct StringErase_ <Container,void,void>
3563 : euml_action<StringErase_<Container,void,void> >
3566 template <class Event,class FSM,class STATE >
3567 struct state_action_result
3569 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3571 template <class EVT,class FSM,class SourceState,class TargetState>
3572 struct transition_action_result
3574 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3576 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3582 return (Container()(evt,fsm,src,tgt)).erase();
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
3588 return (Container()(evt,fsm,state)).erase();
3592 template <class Container,class Param1>
3593 struct StringErase_ <Container,Param1,void>
3594 : euml_action<StringErase_<Container,Param1,void> >
3596 template <class Event,class FSM,class STATE >
3597 struct state_action_result
3599 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3601 template <class EVT,class FSM,class SourceState,class TargetState>
3602 struct transition_action_result
3604 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3606 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3612 return (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
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
3618 return (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
3622 struct string_erase_tag {};
3623 struct StringErase_Helper: proto::extends< proto::terminal<string_erase_tag>::type, StringErase_Helper, boost::msm::sm_domain>
3625 StringErase_Helper(){}
3626 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3633 typedef StringErase_<Arg1,Arg2,Arg3> type;
3636 StringErase_Helper const string_erase_;
3638 template <class Container, class Param1, class Param2, class Param3 >
3639 struct StringAssign_ : euml_action<StringAssign_<Container,Param1,Param2,Param3> >
3641 template <class Event,class FSM,class STATE >
3642 struct state_action_result
3644 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3646 template <class EVT,class FSM,class SourceState,class TargetState>
3647 struct transition_action_result
3649 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3651 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3660 return (Container()(evt,fsm,src,tgt)).assign (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3661 Param3()(evt,fsm,src,tgt));
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
3670 return (Container()(evt,fsm,state)).assign (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3671 Param3()(evt,fsm,state));
3674 template <class Container,class Param1>
3675 struct StringAssign_ <
3676 Container,Param1,void,void>
3677 : euml_action<StringAssign_<Container,Param1,void,void> >
3679 template <class Event,class FSM,class STATE >
3680 struct state_action_result
3682 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3684 template <class EVT,class FSM,class SourceState,class TargetState>
3685 struct transition_action_result
3687 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3689 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3698 return (Container()(evt,fsm,src,tgt)).assign(Param1()(evt,fsm,src,tgt));
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
3707 return (Container()(evt,fsm,state)).assign(Param1()(evt,fsm,state));
3711 template <class Container, class Param1, class Param2 >
3712 struct StringAssign_<Container,Param1,Param2,void>
3713 : euml_action<StringAssign_<Container,Param1,Param2,void> >
3715 template <class Event,class FSM,class STATE >
3716 struct state_action_result
3718 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3720 template <class EVT,class FSM,class SourceState,class TargetState>
3721 struct transition_action_result
3723 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3725 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3734 return (Container()(evt,fsm,src,tgt)).assign(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
3743 return (Container()(evt,fsm,state)).assign(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3746 struct assign_tag {};
3747 struct StringAssign_Helper: proto::extends< proto::terminal<assign_tag>::type, StringAssign_Helper, boost::msm::sm_domain>
3749 StringAssign_Helper(){}
3750 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3757 typedef StringAssign_<Arg1,Arg2,Arg3,Arg4> type;
3760 StringAssign_Helper const string_assign_;
3762 template <class Container,class Param1, class Param2, class Param3, class Param4>
3763 struct StringReplace_ : euml_action<StringReplace_<Container,Param1,Param2,Param3,Param4> >
3765 template <class Event,class FSM,class STATE >
3766 struct state_action_result
3768 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3770 template <class EVT,class FSM,class SourceState,class TargetState>
3771 struct transition_action_result
3773 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3775 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
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));
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
3794 return (Container()(evt,fsm,state)).replace (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3795 Param3()(evt,fsm,state),Param4()(evt,fsm,state));
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> >
3803 template <class Event,class FSM,class STATE >
3804 struct state_action_result
3806 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3808 template <class EVT,class FSM,class SourceState,class TargetState>
3809 struct transition_action_result
3811 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3813 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3822 return (Container()(evt,fsm,src,tgt)).replace(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3823 Param3()(evt,fsm,src,tgt));
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
3832 return (Container()(evt,fsm,state)).replace(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3833 Param3()(evt,fsm,state));
3837 struct string_replace_tag {};
3838 struct StringReplace_Helper: proto::extends< proto::terminal<string_replace_tag>::type, StringReplace_Helper, boost::msm::sm_domain>
3840 StringReplace_Helper(){}
3841 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3848 typedef StringReplace_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3851 StringReplace_Helper const string_replace_;
3853 template <class Container>
3854 struct CStr_ : euml_action<CStr_<Container> >
3856 template <class Event,class FSM,class STATE >
3857 struct state_action_result
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;
3864 template <class EVT,class FSM,class SourceState,class TargetState>
3865 struct transition_action_result
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;
3872 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3881 return (Container()(evt,fsm,src,tgt)).c_str();
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
3890 return (Container()(evt,fsm,state)).c_str();
3893 struct c_str_tag {};
3894 struct CStr_Helper: proto::extends< proto::terminal<c_str_tag>::type, CStr_Helper, boost::msm::sm_domain>
3897 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3904 typedef CStr_<Arg1> type;
3907 CStr_Helper const c_str_;
3909 template <class Container>
3910 struct StringData_ : euml_action<StringData_<Container> >
3912 template <class Event,class FSM,class STATE >
3913 struct state_action_result
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;
3920 template <class EVT,class FSM,class SourceState,class TargetState>
3921 struct transition_action_result
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;
3928 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3937 return (Container()(evt,fsm,src,tgt)).data();
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
3946 return (Container()(evt,fsm,state)).data();
3949 struct string_data_tag {};
3950 struct StringData_Helper: proto::extends< proto::terminal<string_data_tag>::type, StringData_Helper, boost::msm::sm_domain>
3952 StringData_Helper(){}
3953 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3960 typedef StringData_<Arg1> type;
3963 StringData_Helper const string_data_;
3965 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
3966 struct StringCopy_ : euml_action<StringCopy_<Container,Param1,Param2,Param3,Enable> >
3970 template <class Container,class Param1, class Param2, class Param3>
3972 Container,Param1,Param2,Param3,
3973 typename ::boost::enable_if<
3974 typename ::boost::is_same<Param3,void>::type
3977 : euml_action<StringCopy_<Container,Param1,Param2,Param3> >
3979 template <class Event,class FSM,class STATE >
3980 struct state_action_result
3982 typedef typename get_size_type<
3983 typename ::boost::remove_reference<
3984 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
3986 template <class EVT,class FSM,class SourceState,class TargetState>
3987 struct transition_action_result
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;
3993 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
3999 return (Container()(evt,fsm,src,tgt)).copy(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
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
4005 return (Container()(evt,fsm,state)).copy(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
4009 template <class Container,class Param1, class Param2, class Param3>
4011 Container,Param1,Param2,Param3,
4012 typename ::boost::disable_if<
4013 typename ::boost::is_same<Param3,void>::type
4016 : euml_action<StringCopy_<Container,Param1,Param2,Param3> >
4018 template <class Event,class FSM,class STATE >
4019 struct state_action_result
4021 typedef typename get_size_type<
4022 typename ::boost::remove_reference<
4023 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
4025 template <class EVT,class FSM,class SourceState,class TargetState>
4026 struct transition_action_result
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;
4032 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
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
4038 return (Container()(evt,fsm,src,tgt)).
4039 copy(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
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
4045 return (Container()(evt,fsm,state)).
4046 copy(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
4050 struct string_copy_tag {};
4051 struct StringCopy_Helper: proto::extends< proto::terminal<string_copy_tag>::type, StringCopy_Helper, boost::msm::sm_domain>
4053 StringCopy_Helper(){}
4054 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
4061 typedef StringCopy_<Arg1,Arg2,Arg3,Arg4> type;
4064 StringCopy_Helper const string_copy_;
4068 #endif //BOOST_MSM_FRONT_EUML_CONTAINER_H