Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/msm/front/euml/container.hpp @ 16:2665513ce2d3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add boost headers
author Chris Cannam
date Tue, 05 Aug 2014 11:11:38 +0100
parents
children
comparison
equal deleted inserted replaced
15:663ca0da4350 16:2665513ce2d3
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)
10
11 #ifndef BOOST_MSM_FRONT_EUML_CONTAINER_H
12 #define BOOST_MSM_FRONT_EUML_CONTAINER_H
13
14 #include <utility>
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>
22
23 BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
24
25 namespace boost { namespace msm { namespace front { namespace euml
26 {
27
28 template <class T>
29 struct Front_ : euml_action<Front_<T> >
30 {
31 template <class Event,class FSM,class STATE >
32 struct state_action_result
33 {
34 typedef typename get_reference<
35 typename ::boost::remove_reference<
36 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
37 };
38 template <class EVT,class FSM,class SourceState,class TargetState>
39 struct transition_action_result
40 {
41 typedef typename get_reference<
42 typename ::boost::remove_reference<
43 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
44 };
45 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
46
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
53 {
54 return (T()(evt,fsm,src,tgt)).front();
55 }
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
62 {
63 return (T()(evt,fsm,state)).front();
64 }
65 };
66
67 struct front_tag {};
68 struct Front_Helper: proto::extends< proto::terminal<front_tag>::type, Front_Helper, boost::msm::sm_domain>
69 {
70 Front_Helper(){}
71 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
72 #ifdef BOOST_MSVC
73 ,class Arg6
74 #endif
75 >
76 struct In
77 {
78 typedef Front_<Arg1> type;
79 };
80 };
81 Front_Helper const front_;
82
83 template <class T>
84 struct Back_ : euml_action<Back_<T> >
85 {
86 template <class Event,class FSM,class STATE >
87 struct state_action_result
88 {
89 typedef typename get_reference<
90 typename ::boost::remove_reference<
91 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
92 };
93 template <class EVT,class FSM,class SourceState,class TargetState>
94 struct transition_action_result
95 {
96 typedef typename get_reference<
97 typename ::boost::remove_reference<
98 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
99 };
100 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
101
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
108 {
109 return (T()(evt,fsm,src,tgt)).back();
110 }
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
117 {
118 return (T()(evt,fsm,state)).back();
119 }
120 };
121
122 struct back_tag {};
123 struct Back_Helper: proto::extends< proto::terminal<back_tag>::type, Back_Helper, boost::msm::sm_domain>
124 {
125 Back_Helper(){}
126 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
127 #ifdef BOOST_MSVC
128 ,class Arg6
129 #endif
130 >
131 struct In
132 {
133 typedef Back_<Arg1> type;
134 };
135 };
136 Back_Helper const back_;
137
138 template <class T>
139 struct Begin_ : euml_action<Begin_<T> >
140 {
141 template <class Event,class FSM,class STATE >
142 struct state_action_result
143 {
144 typedef typename get_iterator<
145 typename ::boost::remove_reference<
146 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
147 };
148 template <class EVT,class FSM,class SourceState,class TargetState>
149 struct transition_action_result
150 {
151 typedef typename get_iterator<
152 typename ::boost::remove_reference<
153 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
154 };
155 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
156
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
163 {
164 return (T()(evt,fsm,src,tgt)).begin();
165 }
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
172 {
173 return (T()(evt,fsm,state)).begin();
174 }
175 };
176
177 struct begin_tag {};
178 struct Begin_Helper: proto::extends< proto::terminal<begin_tag>::type, Begin_Helper, boost::msm::sm_domain>
179 {
180 Begin_Helper(){}
181 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
182 #ifdef BOOST_MSVC
183 ,class Arg6
184 #endif
185 >
186 struct In
187 {
188 typedef Begin_<Arg1> type;
189 };
190 };
191 Begin_Helper const begin_;
192
193 template <class T>
194 struct End_ : euml_action<End_<T> >
195 {
196 template <class Event,class FSM,class STATE >
197 struct state_action_result
198 {
199 typedef typename get_iterator<
200 typename ::boost::remove_reference<
201 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
202 };
203 template <class EVT,class FSM,class SourceState,class TargetState>
204 struct transition_action_result
205 {
206 typedef typename get_iterator<
207 typename ::boost::remove_reference<
208 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
209 };
210 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
211
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
218 {
219 return (T()(evt,fsm,src,tgt)).end();
220 }
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
227 {
228 return (T()(evt,fsm,state)).end();
229 }
230 };
231 struct end_tag {};
232 struct End_Helper: proto::extends< proto::terminal<end_tag>::type, End_Helper, boost::msm::sm_domain>
233 {
234 End_Helper(){}
235 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
236 #ifdef BOOST_MSVC
237 ,class Arg6
238 #endif
239 >
240 struct In
241 {
242 typedef End_<Arg1> type;
243 };
244 };
245 End_Helper const end_;
246
247 template <class T>
248 struct RBegin_ : euml_action<RBegin_<T> >
249 {
250 template <class Event,class FSM,class STATE >
251 struct state_action_result
252 {
253 typedef typename get_reverse_iterator<
254 typename ::boost::remove_reference<
255 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
256 };
257 template <class EVT,class FSM,class SourceState,class TargetState>
258 struct transition_action_result
259 {
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;
263 };
264 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
265
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
272 {
273 return (T()(evt,fsm,src,tgt)).rbegin();
274 }
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
281 {
282 return (T()(evt,fsm,state)).rbegin();
283 }
284 };
285
286 struct rbegin_tag {};
287 struct RBegin_Helper: proto::extends< proto::terminal<rbegin_tag>::type, RBegin_Helper, boost::msm::sm_domain>
288 {
289 RBegin_Helper(){}
290 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
291 #ifdef BOOST_MSVC
292 ,class Arg6
293 #endif
294 >
295 struct In
296 {
297 typedef RBegin_<Arg1> type;
298 };
299 };
300 RBegin_Helper const rbegin_;
301
302 template <class T>
303 struct REnd_ : euml_action<REnd_<T> >
304 {
305 template <class Event,class FSM,class STATE >
306 struct state_action_result
307 {
308 typedef typename get_reverse_iterator<
309 typename ::boost::remove_reference<
310 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
311 };
312 template <class EVT,class FSM,class SourceState,class TargetState>
313 struct transition_action_result
314 {
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;
318 };
319 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
320
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
327 {
328 return (T()(evt,fsm,src,tgt)).rend();
329 }
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
336 {
337 return (T()(evt,fsm,state)).rend();
338 }
339 };
340 struct rend_tag {};
341 struct REnd_Helper: proto::extends< proto::terminal<rend_tag>::type, REnd_Helper, boost::msm::sm_domain>
342 {
343 REnd_Helper(){}
344 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
345 #ifdef BOOST_MSVC
346 ,class Arg6
347 #endif
348 >
349 struct In
350 {
351 typedef REnd_<Arg1> type;
352 };
353 };
354 REnd_Helper const rend_;
355
356 template <class Container,class Element>
357 struct Push_Back_ : euml_action<Push_Back_<Container,Element> >
358 {
359 template <class Event,class FSM,class STATE >
360 struct state_action_result
361 {
362 typedef void type;
363 };
364 template <class EVT,class FSM,class SourceState,class TargetState>
365 struct transition_action_result
366 {
367 typedef void type;
368 };
369 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
370
371 template <class EVT,class FSM,class SourceState,class TargetState>
372 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
373 {
374 (Container()(evt,fsm,src,tgt)).push_back(Element()(evt,fsm,src,tgt));
375 }
376 template <class Event,class FSM,class STATE>
377 void operator()(Event const& evt,FSM& fsm,STATE& state )const
378 {
379 (Container()(evt,fsm,state)).push_back(Element()(evt,fsm,state));
380 }
381 };
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>
384 {
385 Push_Back_Helper(){}
386 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
387 #ifdef BOOST_MSVC
388 ,class Arg6
389 #endif
390 >
391 struct In
392 {
393 typedef Push_Back_<Arg1,Arg2> type;
394 };
395 };
396 Push_Back_Helper const push_back_;
397
398 template <class Container>
399 struct Pop_Back_ : euml_action<Pop_Back_<Container> >
400 {
401 template <class Event,class FSM,class STATE >
402 struct state_action_result
403 {
404 typedef void type;
405 };
406 template <class EVT,class FSM,class SourceState,class TargetState>
407 struct transition_action_result
408 {
409 typedef void type;
410 };
411 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
412
413 template <class EVT,class FSM,class SourceState,class TargetState>
414 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
415 {
416 (Container()(evt,fsm,src,tgt)).pop_back();
417 }
418 template <class Event,class FSM,class STATE>
419 void operator()(Event const& evt,FSM& fsm,STATE& state )const
420 {
421 (Container()(evt,fsm,state)).pop_back();
422 }
423 };
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>
426 {
427 Pop_Back_Helper(){}
428 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
429 #ifdef BOOST_MSVC
430 ,class Arg6
431 #endif
432 >
433 struct In
434 {
435 typedef Pop_Back_<Arg1> type;
436 };
437 };
438 Pop_Back_Helper const pop_back_;
439
440 template <class Container,class Element>
441 struct Push_Front_ : euml_action<Push_Front_<Container,Element> >
442 {
443 template <class Event,class FSM,class STATE >
444 struct state_action_result
445 {
446 typedef void type;
447 };
448 template <class EVT,class FSM,class SourceState,class TargetState>
449 struct transition_action_result
450 {
451 typedef void type;
452 };
453 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
454
455 template <class EVT,class FSM,class SourceState,class TargetState>
456 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
457 {
458 (Container()(evt,fsm,src,tgt)).push_front(Element()(evt,fsm,src,tgt));
459 }
460 template <class Event,class FSM,class STATE>
461 void operator()(Event const& evt,FSM& fsm,STATE& state )const
462 {
463 (Container()(evt,fsm,state)).push_front(Element()(evt,fsm,state));
464 }
465 };
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>
468 {
469 Push_Front_Helper(){}
470 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
471 #ifdef BOOST_MSVC
472 ,class Arg6
473 #endif
474 >
475 struct In
476 {
477 typedef Push_Front_<Arg1,Arg2> type;
478 };
479 };
480 Push_Front_Helper const push_front_;
481
482 template <class Container>
483 struct Pop_Front_ : euml_action<Pop_Front_<Container> >
484 {
485 template <class Event,class FSM,class STATE >
486 struct state_action_result
487 {
488 typedef void type;
489 };
490 template <class EVT,class FSM,class SourceState,class TargetState>
491 struct transition_action_result
492 {
493 typedef void type;
494 };
495 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
496
497 template <class EVT,class FSM,class SourceState,class TargetState>
498 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
499 {
500 (Container()(evt,fsm,src,tgt)).pop_front();
501 }
502 template <class Event,class FSM,class STATE>
503 void operator()(Event const& evt,FSM& fsm,STATE& state )const
504 {
505 (Container()(evt,fsm,state)).pop_front();
506 }
507 };
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>
510 {
511 Pop_Front_Helper(){}
512 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
513 #ifdef BOOST_MSVC
514 ,class Arg6
515 #endif
516 >
517 struct In
518 {
519 typedef Pop_Front_<Arg1> type;
520 };
521 };
522 Pop_Front_Helper const pop_front_;
523
524 template <class Container>
525 struct Clear_ : euml_action<Clear_<Container> >
526 {
527 template <class Event,class FSM,class STATE >
528 struct state_action_result
529 {
530 typedef void type;
531 };
532 template <class EVT,class FSM,class SourceState,class TargetState>
533 struct transition_action_result
534 {
535 typedef void type;
536 };
537 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
538
539 template <class EVT,class FSM,class SourceState,class TargetState>
540 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
541 {
542 (Container()(evt,fsm,src,tgt)).clear();
543 }
544 template <class Event,class FSM,class STATE>
545 void operator()(Event const& evt,FSM& fsm,STATE& state )const
546 {
547 (Container()(evt,fsm,state)).clear();
548 }
549 };
550 struct clear_tag {};
551 struct Clear_Helper: proto::extends< proto::terminal<clear_tag>::type, Clear_Helper, boost::msm::sm_domain>
552 {
553 Clear_Helper(){}
554 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
555 #ifdef BOOST_MSVC
556 ,class Arg6
557 #endif
558 >
559 struct In
560 {
561 typedef Clear_<Arg1> type;
562 };
563 };
564 Clear_Helper const clear_;
565
566 template <class Container>
567 struct ListReverse_ : euml_action<ListReverse_<Container> >
568 {
569 template <class Event,class FSM,class STATE >
570 struct state_action_result
571 {
572 typedef void type;
573 };
574 template <class EVT,class FSM,class SourceState,class TargetState>
575 struct transition_action_result
576 {
577 typedef void type;
578 };
579 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
580
581 template <class EVT,class FSM,class SourceState,class TargetState>
582 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
583 {
584 (Container()(evt,fsm,src,tgt)).reverse();
585 }
586 template <class Event,class FSM,class STATE>
587 void operator()(Event const& evt,FSM& fsm,STATE& state )const
588 {
589 (Container()(evt,fsm,state)).reverse();
590 }
591 };
592 struct list_reverse_tag {};
593 struct ListReverse_Helper: proto::extends< proto::terminal<list_reverse_tag>::type, ListReverse_Helper, boost::msm::sm_domain>
594 {
595 ListReverse_Helper(){}
596 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
597 #ifdef BOOST_MSVC
598 ,class Arg6
599 #endif
600 >
601 struct In
602 {
603 typedef ListReverse_<Arg1> type;
604 };
605 };
606 ListReverse_Helper const list_reverse_;
607
608 template <class Container, class Predicate, class Enable=void>
609 struct ListUnique_ : euml_action<ListUnique_<Container,Predicate,Enable> >
610 {
611 template <class Event,class FSM,class STATE >
612 struct state_action_result
613 {
614 typedef void type;
615 };
616 template <class EVT,class FSM,class SourceState,class TargetState>
617 struct transition_action_result
618 {
619 typedef void type;
620 };
621 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
622
623 template <class EVT,class FSM,class SourceState,class TargetState>
624 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
625 {
626 (Container()(evt,fsm,src,tgt)).unique();
627 }
628 template <class Event,class FSM,class STATE>
629 void operator()(Event const& evt,FSM& fsm,STATE& state )const
630 {
631 (Container()(evt,fsm,state)).unique();
632 }
633 };
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> >
638 {
639 template <class Event,class FSM,class STATE >
640 struct state_action_result
641 {
642 typedef void type;
643 };
644 template <class EVT,class FSM,class SourceState,class TargetState>
645 struct transition_action_result
646 {
647 typedef void type;
648 };
649 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
650
651 template <class EVT,class FSM,class SourceState,class TargetState>
652 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
653 {
654 (Container()(evt,fsm,src,tgt)).unique(Predicate()(evt,fsm,src,tgt));
655 }
656 template <class Event,class FSM,class STATE>
657 void operator()(Event const& evt,FSM& fsm,STATE& state )const
658 {
659 (Container()(evt,fsm,state)).unique(Predicate()(evt,fsm,state));
660 }
661 };
662 struct list_unique_tag {};
663 struct ListUnique_Helper: proto::extends< proto::terminal<list_unique_tag>::type, ListUnique_Helper, boost::msm::sm_domain>
664 {
665 ListUnique_Helper(){}
666 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
667 #ifdef BOOST_MSVC
668 ,class Arg6
669 #endif
670 >
671 struct In
672 {
673 typedef ListUnique_<Arg1,Arg2> type;
674 };
675 };
676 ListUnique_Helper const list_unique_;
677
678 template <class Container, class Predicate, class Enable=void>
679 struct ListSort_ : euml_action<ListSort_<Container,Predicate,Enable> >
680 {
681 template <class Event,class FSM,class STATE >
682 struct state_action_result
683 {
684 typedef void type;
685 };
686 template <class EVT,class FSM,class SourceState,class TargetState>
687 struct transition_action_result
688 {
689 typedef void type;
690 };
691 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
692
693 template <class EVT,class FSM,class SourceState,class TargetState>
694 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
695 {
696 (Container()(evt,fsm,src,tgt)).sort();
697 }
698 template <class Event,class FSM,class STATE>
699 void operator()(Event const& evt,FSM& fsm,STATE& state )const
700 {
701 (Container()(evt,fsm,state)).sort();
702 }
703 };
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> >
708 {
709 template <class Event,class FSM,class STATE >
710 struct state_action_result
711 {
712 typedef void type;
713 };
714 template <class EVT,class FSM,class SourceState,class TargetState>
715 struct transition_action_result
716 {
717 typedef void type;
718 };
719 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
720
721 template <class EVT,class FSM,class SourceState,class TargetState>
722 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
723 {
724 (Container()(evt,fsm,src,tgt)).sort(Predicate()(evt,fsm,src,tgt));
725 }
726 template <class Event,class FSM,class STATE>
727 void operator()(Event const& evt,FSM& fsm,STATE& state )const
728 {
729 (Container()(evt,fsm,state)).sort(Predicate()(evt,fsm,state));
730 }
731 };
732 struct list_sort_tag {};
733 struct ListSort_Helper: proto::extends< proto::terminal<list_sort_tag>::type, ListSort_Helper, boost::msm::sm_domain>
734 {
735 ListSort_Helper(){}
736 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
737 #ifdef BOOST_MSVC
738 ,class Arg6
739 #endif
740 >
741 struct In
742 {
743 typedef ListSort_<Arg1,Arg2> type;
744 };
745 };
746 ListSort_Helper const list_sort_;
747
748 template <class Container>
749 struct Capacity_ : euml_action<Capacity_<Container> >
750 {
751 template <class Event,class FSM,class STATE >
752 struct state_action_result
753 {
754 typedef typename get_size_type<
755 typename ::boost::remove_reference<
756 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
757 };
758 template <class EVT,class FSM,class SourceState,class TargetState>
759 struct transition_action_result
760 {
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;
764 };
765 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
766
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
773 {
774 return (Container()(evt,fsm,src,tgt)).capacity();
775 }
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
782 {
783 return (Container()(evt,fsm,state)).capacity();
784 }
785 };
786 struct capacity_tag {};
787 struct Capacity_Helper: proto::extends< proto::terminal<capacity_tag>::type, Capacity_Helper, boost::msm::sm_domain>
788 {
789 Capacity_Helper(){}
790 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
791 #ifdef BOOST_MSVC
792 ,class Arg6
793 #endif
794 >
795 struct In
796 {
797 typedef Capacity_<Arg1> type;
798 };
799 };
800 Capacity_Helper const capacity_;
801
802 template <class Container>
803 struct Size_ : euml_action<Size_<Container> >
804 {
805 template <class Event,class FSM,class STATE >
806 struct state_action_result
807 {
808 typedef typename get_size_type<
809 typename ::boost::remove_reference<
810 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
811 };
812 template <class EVT,class FSM,class SourceState,class TargetState>
813 struct transition_action_result
814 {
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;
818 };
819 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
820
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
827 {
828 return (Container()(evt,fsm,src,tgt)).size();
829 }
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
836 {
837 return (Container()(evt,fsm,state)).size();
838 }
839 };
840 struct size_tag {};
841 struct Size_Helper: proto::extends< proto::terminal<size_tag>::type, Size_Helper, boost::msm::sm_domain>
842 {
843 Size_Helper(){}
844 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
845 #ifdef BOOST_MSVC
846 ,class Arg6
847 #endif
848 >
849 struct In
850 {
851 typedef Size_<Arg1> type;
852 };
853 };
854 Size_Helper const size_;
855
856 template <class Container>
857 struct Max_Size_ : euml_action<Max_Size_<Container> >
858 {
859 template <class Event,class FSM,class STATE >
860 struct state_action_result
861 {
862 typedef typename get_size_type<
863 typename ::boost::remove_reference<
864 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
865 };
866 template <class EVT,class FSM,class SourceState,class TargetState>
867 struct transition_action_result
868 {
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;
872 };
873 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
874
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
881 {
882 return (Container()(evt,fsm,src,tgt)).max_size();
883 }
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
890 {
891 return (Container()(evt,fsm,state)).max_size();
892 }
893 };
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>
896 {
897 Max_Size_Helper(){}
898 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
899 #ifdef BOOST_MSVC
900 ,class Arg6
901 #endif
902 >
903 struct In
904 {
905 typedef Max_Size_<Arg1> type;
906 };
907 };
908 Max_Size_Helper const max_size_;
909
910 template <class Container, class Value>
911 struct Reserve_ : euml_action<Reserve_<Container,Value> >
912 {
913 template <class Event,class FSM,class STATE >
914 struct state_action_result
915 {
916 typedef void type;
917 };
918 template <class EVT,class FSM,class SourceState,class TargetState>
919 struct transition_action_result
920 {
921 typedef void type;
922 };
923 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
924
925 template <class EVT,class FSM,class SourceState,class TargetState>
926 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
927 {
928 (Container()(evt,fsm,src,tgt)).reserve(Value()(evt,fsm,src,tgt));
929 }
930 template <class Event,class FSM,class STATE>
931 void operator()(Event const& evt,FSM& fsm,STATE& state )const
932 {
933 (Container()(evt,fsm,state)).reserve(Value()(evt,fsm,state));
934 }
935 };
936 struct reserve_tag {};
937 struct Reserve_Helper: proto::extends< proto::terminal<reserve_tag>::type, Reserve_Helper, boost::msm::sm_domain>
938 {
939 Reserve_Helper(){}
940 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
941 #ifdef BOOST_MSVC
942 ,class Arg6
943 #endif
944 >
945 struct In
946 {
947 typedef Reserve_<Arg1,Arg2> type;
948 };
949 };
950 Reserve_Helper const reserve_;
951
952 template <class Container, class Num, class Value ,class Enable=void >
953 struct Resize_ : euml_action<Resize_<Container,Num,Value> >
954 {
955 template <class Event,class FSM,class STATE >
956 struct state_action_result
957 {
958 typedef void type;
959 };
960 template <class EVT,class FSM,class SourceState,class TargetState>
961 struct transition_action_result
962 {
963 typedef void type;
964 };
965 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
966
967 template <class EVT,class FSM,class SourceState,class TargetState>
968 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
969 {
970 (Container()(evt,fsm,src,tgt)).resize(Num()(evt,fsm,src,tgt));
971 }
972 template <class Event,class FSM,class STATE>
973 void operator()(Event const& evt,FSM& fsm,STATE& state )const
974 {
975 (Container()(evt,fsm,state)).resize(Num()(evt,fsm,state));
976 }
977 };
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> >
981 {
982 template <class Event,class FSM,class STATE >
983 struct state_action_result
984 {
985 typedef void type;
986 };
987 template <class EVT,class FSM,class SourceState,class TargetState>
988 struct transition_action_result
989 {
990 typedef void type;
991 };
992 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
993
994 template <class EVT,class FSM,class SourceState,class TargetState>
995 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
996 {
997 (Container()(evt,fsm,src,tgt)).resize(Num()(evt,fsm,src,tgt),Value()(evt,fsm,src,tgt));
998 }
999 template <class Event,class FSM,class STATE>
1000 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1001 {
1002 (Container()(evt,fsm,state)).resize(Num()(evt,fsm,state),Value()(evt,fsm,state));
1003 }
1004 };
1005 struct resize_tag {};
1006 struct Resize_Helper: proto::extends< proto::terminal<resize_tag>::type, Resize_Helper, boost::msm::sm_domain>
1007 {
1008 Resize_Helper(){}
1009 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1010 #ifdef BOOST_MSVC
1011 ,class Arg6
1012 #endif
1013 >
1014 struct In
1015 {
1016 typedef Resize_<Arg1,Arg2,Arg3> type;
1017 };
1018 };
1019 Resize_Helper const resize_;
1020
1021 // version for 3 parameters (sequence containers)
1022 template <class Container, class Param1, class Param2, class Param3 >
1023 struct Insert_ : euml_action<Insert_<Container,Param1,Param2,Param3> >
1024 {
1025 template <class Event,class FSM,class STATE >
1026 struct state_action_result
1027 {
1028 typedef void type;
1029 };
1030 template <class EVT,class FSM,class SourceState,class TargetState>
1031 struct transition_action_result
1032 {
1033 typedef void type;
1034 };
1035 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1036
1037 template <class EVT,class FSM,class SourceState,class TargetState>
1038 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1039 {
1040 (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
1041 Param3()(evt,fsm,src,tgt));
1042 }
1043 template <class Event,class FSM,class STATE>
1044 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1045 {
1046 (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1047 Param3()(evt,fsm,state));
1048 }
1049 };
1050 // version for 2 parameters
1051 template <class Container, class Param1, class Param2>
1052 struct Insert_ < Container,Param1,Param2,void>
1053 : euml_action<Insert_<Container,Param1,Param2,void> >
1054 {
1055 // return value will actually not be correct for set::insert(it1,it2), should be void
1056 // but it's ok as nobody should call an inexistent return type
1057 template <class Event,class FSM,class STATE >
1058 struct state_action_result
1059 {
1060 typedef typename get_iterator<
1061 typename ::boost::remove_reference<
1062 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
1063 };
1064 template <class EVT,class FSM,class SourceState,class TargetState>
1065 struct transition_action_result
1066 {
1067 typedef typename get_iterator<
1068 typename ::boost::remove_reference<
1069 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
1070 };
1071 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1072
1073 // version for transition + second param not an iterator (meaning that, Container is not an associative container)
1074 template <class EVT,class FSM,class SourceState,class TargetState>
1075 typename ::boost::enable_if<
1076 typename ::boost::mpl::and_<
1077 typename ::boost::mpl::has_key<
1078 typename Container::tag_type,action_tag>::type,
1079 typename ::boost::mpl::not_<
1080 typename has_iterator_category<
1081 typename Param2::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
1082 >::type
1083 >::type
1084 >::type,
1085 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1086 >::type
1087 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1088 {
1089 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1090 }
1091
1092 // version for transition + second param is an iterator (meaning that, Container is an associative container)
1093 template <class EVT,class FSM,class SourceState,class TargetState>
1094 typename ::boost::enable_if<
1095 typename ::boost::mpl::and_<
1096 typename ::boost::mpl::has_key<
1097 typename Container::tag_type,action_tag>::type,
1098 typename has_iterator_category<
1099 typename Param2::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
1100 >::type
1101 >::type,
1102 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1103 >::type
1104 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1105 {
1106 (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1107 }
1108
1109 // version for state action + second param not an iterator (meaning that, Container is not an associative container)
1110 template <class Event,class FSM,class STATE>
1111 typename ::boost::enable_if<
1112 typename ::boost::mpl::and_<
1113 typename ::boost::mpl::has_key<
1114 typename Container::tag_type,state_action_tag>::type,
1115 typename ::boost::mpl::not_<
1116 typename has_iterator_category<
1117 typename Param2::template state_action_result<Event,FSM,STATE>::type
1118 >::type
1119 >::type
1120 >::type,
1121 typename state_action_result<Event,FSM,STATE>::type
1122 >::type
1123 operator()(Event const& evt,FSM& fsm,STATE& state )const
1124 {
1125 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1126 }
1127
1128 // version for state action + second param is an iterator (meaning that, Container is an associative container)
1129 template <class Event,class FSM,class STATE>
1130 typename ::boost::enable_if<
1131 typename ::boost::mpl::and_<
1132 typename ::boost::mpl::has_key<
1133 typename Container::tag_type,state_action_tag>::type,
1134 typename has_iterator_category<
1135 typename Param2::template state_action_result<Event,FSM,STATE>::type
1136 >::type
1137 >::type,
1138 typename state_action_result<Event,FSM,STATE>::type
1139 >::type
1140 operator()(Event const& evt,FSM& fsm,STATE& state )const
1141 {
1142 (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1143 }
1144 };
1145
1146 // version for 1 parameter (associative containers)
1147 template <class Container, class Param1>
1148 struct Insert_ < Container,Param1,void,void>
1149 : euml_action<Insert_<Container,Param1,void,void> >
1150 {
1151 template <class Event,class FSM,class STATE >
1152 struct state_action_result
1153 {
1154 typedef typename std::pair<
1155 typename get_iterator<
1156 typename ::boost::remove_reference<
1157 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type,bool> type;
1158 };
1159 template <class EVT,class FSM,class SourceState,class TargetState>
1160 struct transition_action_result
1161 {
1162 typedef typename std::pair<
1163 typename get_iterator<
1164 typename ::boost::remove_reference<
1165 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type,bool> type;
1166 };
1167 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1168
1169 template <class EVT,class FSM,class SourceState,class TargetState>
1170 typename ::boost::enable_if<
1171 typename ::boost::mpl::has_key<
1172 typename Container::tag_type,action_tag>::type,
1173 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
1174 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1175 {
1176 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt));
1177 }
1178 template <class Event,class FSM,class STATE>
1179 typename ::boost::enable_if<
1180 typename ::boost::mpl::has_key<
1181 typename Container::tag_type,state_action_tag>::type,
1182 typename state_action_result<Event,FSM,STATE>::type >::type
1183 operator()(Event const& evt,FSM& fsm,STATE& state )const
1184 {
1185 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state));
1186 }
1187 };
1188 struct insert_tag {};
1189 struct Insert_Helper: proto::extends< proto::terminal<insert_tag>::type, Insert_Helper, boost::msm::sm_domain>
1190 {
1191 Insert_Helper(){}
1192 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1193 #ifdef BOOST_MSVC
1194 ,class Arg6
1195 #endif
1196 >
1197 struct In
1198 {
1199 typedef Insert_<Arg1,Arg2,Arg3,Arg4> type;
1200 };
1201 };
1202 Insert_Helper const insert_;
1203
1204 template <class Container1,class Container2>
1205 struct Swap_ : euml_action<Swap_<Container1,Container2> >
1206 {
1207 template <class Event,class FSM,class STATE >
1208 struct state_action_result
1209 {
1210 typedef void type;
1211 };
1212 template <class EVT,class FSM,class SourceState,class TargetState>
1213 struct transition_action_result
1214 {
1215 typedef void type;
1216 };
1217 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1218
1219 template <class EVT,class FSM,class SourceState,class TargetState>
1220 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1221 {
1222 (Container1()(evt,fsm,src,tgt)).swap(Container2()(evt,fsm,src,tgt));
1223 }
1224 template <class Event,class FSM,class STATE>
1225 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1226 {
1227 (Container1()(evt,fsm,state)).swap(Container2()(evt,fsm,state));
1228 }
1229 };
1230 struct swap_tag {};
1231 struct Swap_Helper: proto::extends< proto::terminal<swap_tag>::type, Swap_Helper, boost::msm::sm_domain>
1232 {
1233 Swap_Helper(){}
1234 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1235 #ifdef BOOST_MSVC
1236 ,class Arg6
1237 #endif
1238 >
1239 struct In
1240 {
1241 typedef Swap_<Arg1,Arg2> type;
1242 };
1243 };
1244 Swap_Helper const swap_;
1245
1246 template <class Container, class Iterator1, class Iterator2 ,class Enable=void >
1247 struct Erase_ : euml_action<Erase_<Container,Iterator1,Iterator2> >
1248 {
1249 template <class Event,class FSM,class STATE >
1250 struct state_action_result
1251 {
1252 typedef typename get_result_type2<Iterator1,Event,FSM,STATE>::type type;
1253 };
1254 template <class EVT,class FSM,class SourceState,class TargetState>
1255 struct transition_action_result
1256 {
1257 typedef typename get_result_type<Iterator1,EVT,FSM,SourceState,TargetState>::type type;
1258 };
1259 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1260
1261 template <class EVT,class FSM,class SourceState,class TargetState>
1262 typename ::boost::enable_if<
1263 typename ::boost::mpl::has_key<
1264 typename Iterator1::tag_type,action_tag>::type,
1265 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
1266 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1267 {
1268 return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt));
1269 }
1270 template <class Event,class FSM,class STATE>
1271 typename ::boost::enable_if<
1272 typename ::boost::mpl::has_key<
1273 typename Iterator1::tag_type,state_action_tag>::type,
1274 typename state_action_result<Event,FSM,STATE>::type >::type
1275 operator()(Event const& evt,FSM& fsm,STATE& state )const
1276 {
1277 return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state));
1278 }
1279 };
1280 template <class Container, class Iterator1 , class Iterator2 >
1281 struct Erase_<Container,Iterator1,Iterator2,
1282 typename ::boost::disable_if<typename ::boost::is_same<Iterator2,void>::type >::type>
1283 : euml_action<Erase_<Container,Iterator1,Iterator2> >
1284 {
1285 template <class Event,class FSM,class STATE >
1286 struct state_action_result
1287 {
1288 typedef typename get_result_type2<Iterator1,Event,FSM,STATE>::type type;
1289 };
1290 template <class EVT,class FSM,class SourceState,class TargetState>
1291 struct transition_action_result
1292 {
1293 typedef typename get_result_type<Iterator1,EVT,FSM,SourceState,TargetState>::type type;
1294 };
1295 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1296
1297 template <class EVT,class FSM,class SourceState,class TargetState>
1298 typename ::boost::enable_if<
1299 typename ::boost::mpl::has_key<
1300 typename Iterator1::tag_type,action_tag>::type,
1301 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
1302 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1303 {
1304 return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt),Iterator2()(evt,fsm,src,tgt));
1305 }
1306 template <class Event,class FSM,class STATE>
1307 typename ::boost::enable_if<
1308 typename ::boost::mpl::has_key<
1309 typename Iterator1::tag_type,state_action_tag>::type,
1310 typename state_action_result<Event,FSM,STATE>::type >::type
1311 operator()(Event const& evt,FSM& fsm,STATE& state )const
1312 {
1313 return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state),Iterator2()(evt,fsm,state));
1314 }
1315 };
1316 struct erase_tag {};
1317 struct Erase_Helper: proto::extends< proto::terminal<erase_tag>::type, Erase_Helper, boost::msm::sm_domain>
1318 {
1319 Erase_Helper(){}
1320 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1321 #ifdef BOOST_MSVC
1322 ,class Arg6
1323 #endif
1324 >
1325 struct In
1326 {
1327 typedef Erase_<Arg1,Arg2,Arg3> type;
1328 };
1329 };
1330 Erase_Helper const erase_;
1331
1332 template <class Container>
1333 struct Empty_ : euml_action<Empty_<Container> >
1334 {
1335 template <class Event,class FSM,class STATE >
1336 struct state_action_result
1337 {
1338 typedef bool type;
1339 };
1340 template <class EVT,class FSM,class SourceState,class TargetState>
1341 struct transition_action_result
1342 {
1343 typedef bool type;
1344 };
1345 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1346
1347 template <class EVT,class FSM,class SourceState,class TargetState>
1348 bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1349 {
1350 return (Container()(evt,fsm,src,tgt)).empty();
1351 }
1352 template <class Event,class FSM,class STATE>
1353 bool operator()(Event const& evt,FSM& fsm,STATE& state )const
1354 {
1355 return (Container()(evt,fsm,state)).empty();
1356 }
1357 };
1358 struct empty_tag {};
1359 struct Empty_Helper: proto::extends< proto::terminal<empty_tag>::type, Empty_Helper, boost::msm::sm_domain>
1360 {
1361 Empty_Helper(){}
1362 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1363 #ifdef BOOST_MSVC
1364 ,class Arg6
1365 #endif
1366 >
1367 struct In
1368 {
1369 typedef Empty_<Arg1> type;
1370 };
1371 };
1372 Empty_Helper const empty_;
1373
1374 template <class Container,class Element>
1375 struct ListRemove_ : euml_action<ListRemove_<Container,Element> >
1376 {
1377 template <class Event,class FSM,class STATE >
1378 struct state_action_result
1379 {
1380 typedef void type;
1381 };
1382 template <class EVT,class FSM,class SourceState,class TargetState>
1383 struct transition_action_result
1384 {
1385 typedef void type;
1386 };
1387 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1388
1389 template <class EVT,class FSM,class SourceState,class TargetState>
1390 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1391 {
1392 (Container()(evt,fsm,src,tgt)).remove(Element()(evt,fsm,src,tgt));
1393 }
1394 template <class Event,class FSM,class STATE>
1395 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1396 {
1397 (Container()(evt,fsm,state)).remove(Element()(evt,fsm,state));
1398 }
1399 };
1400 struct list_remove_tag {};
1401 struct ListRemove_Helper: proto::extends< proto::terminal<list_remove_tag>::type, ListRemove_Helper, boost::msm::sm_domain>
1402 {
1403 ListRemove_Helper(){}
1404 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1405 #ifdef BOOST_MSVC
1406 ,class Arg6
1407 #endif
1408 >
1409 struct In
1410 {
1411 typedef ListRemove_<Arg1,Arg2> type;
1412 };
1413 };
1414 ListRemove_Helper const list_remove_;
1415
1416 template <class Container,class Element>
1417 struct ListRemove_If_ : euml_action<ListRemove_If_<Container,Element> >
1418 {
1419 template <class Event,class FSM,class STATE >
1420 struct state_action_result
1421 {
1422 typedef void type;
1423 };
1424 template <class EVT,class FSM,class SourceState,class TargetState>
1425 struct transition_action_result
1426 {
1427 typedef void type;
1428 };
1429 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1430
1431 template <class EVT,class FSM,class SourceState,class TargetState>
1432 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1433 {
1434 (Container()(evt,fsm,src,tgt)).remove_if(Element()(evt,fsm,src,tgt));
1435 }
1436 template <class Event,class FSM,class STATE>
1437 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1438 {
1439 (Container()(evt,fsm,state)).remove_if(Element()(evt,fsm,state));
1440 }
1441 };
1442 struct list_remove_if_tag {};
1443 struct ListRemove_If_Helper: proto::extends< proto::terminal<list_remove_if_tag>::type, ListRemove_If_Helper, boost::msm::sm_domain>
1444 {
1445 ListRemove_If_Helper(){}
1446 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1447 #ifdef BOOST_MSVC
1448 ,class Arg6
1449 #endif
1450 >
1451 struct In
1452 {
1453 typedef ListRemove_If_<Arg1,Arg2> type;
1454 };
1455 };
1456 ListRemove_If_Helper const list_remove_if_;
1457
1458 template <class Container, class ToMerge, class Predicate, class Enable=void>
1459 struct ListMerge_ : euml_action<ListMerge_<Container,ToMerge,Predicate,Enable> >
1460 {
1461 template <class Event,class FSM,class STATE >
1462 struct state_action_result
1463 {
1464 typedef void type;
1465 };
1466 template <class EVT,class FSM,class SourceState,class TargetState>
1467 struct transition_action_result
1468 {
1469 typedef void type;
1470 };
1471 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1472
1473 template <class EVT,class FSM,class SourceState,class TargetState>
1474 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1475 {
1476 (Container()(evt,fsm,src,tgt)).merge(ToMerge()(evt,fsm,src,tgt));
1477 }
1478 template <class Event,class FSM,class STATE>
1479 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1480 {
1481 (Container()(evt,fsm,state)).merge(ToMerge()(evt,fsm,state));
1482 }
1483 };
1484 template <class Container, class ToMerge, class Predicate >
1485 struct ListMerge_<Container,ToMerge,Predicate,
1486 typename ::boost::disable_if<typename ::boost::is_same<Predicate,void>::type >::type>
1487 : euml_action<ListMerge_<Container,ToMerge,Predicate> >
1488 {
1489 template <class Event,class FSM,class STATE >
1490 struct state_action_result
1491 {
1492 typedef void type;
1493 };
1494 template <class EVT,class FSM,class SourceState,class TargetState>
1495 struct transition_action_result
1496 {
1497 typedef void type;
1498 };
1499 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1500
1501 template <class EVT,class FSM,class SourceState,class TargetState>
1502 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1503 {
1504 (Container()(evt,fsm,src,tgt)).merge(ToMerge()(evt,fsm,src,tgt),Predicate()(evt,fsm,src,tgt));
1505 }
1506 template <class Event,class FSM,class STATE>
1507 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1508 {
1509 (Container()(evt,fsm,state)).merge(ToMerge()(evt,fsm,state),Predicate()(evt,fsm,state));
1510 }
1511 };
1512 struct list_merge_tag {};
1513 struct ListMerge_Helper: proto::extends< proto::terminal<list_merge_tag>::type, ListMerge_Helper, boost::msm::sm_domain>
1514 {
1515 ListMerge_Helper(){}
1516 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1517 #ifdef BOOST_MSVC
1518 ,class Arg6
1519 #endif
1520 >
1521 struct In
1522 {
1523 typedef ListMerge_<Arg1,Arg2,Arg3> type;
1524 };
1525 };
1526 ListMerge_Helper const list_merge_;
1527
1528 template <class Container, class Param1, class Param2, class Param3, class Param4 ,class Enable=void >
1529 struct Splice_ : euml_action<Splice_<Container,Param1,Param2,Param3,Param4,Enable> >
1530 {
1531 template <class Event,class FSM,class STATE >
1532 struct state_action_result
1533 {
1534 typedef void type;
1535 };
1536 template <class EVT,class FSM,class SourceState,class TargetState>
1537 struct transition_action_result
1538 {
1539 typedef void type;
1540 };
1541 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1542
1543 template <class EVT,class FSM,class SourceState,class TargetState>
1544 typename ::boost::enable_if<
1545 typename ::boost::mpl::has_key<
1546 typename Container::tag_type,action_tag>::type,
1547 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
1548 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1549 {
1550 return (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1551 }
1552 template <class Event,class FSM,class STATE>
1553 typename ::boost::enable_if<
1554 typename ::boost::mpl::has_key<
1555 typename Container::tag_type,state_action_tag>::type,
1556 typename state_action_result<Event,FSM,STATE>::type >::type
1557 operator()(Event const& evt,FSM& fsm,STATE& state )const
1558 {
1559 return (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1560 }
1561 };
1562 template <class Container, class Param1, class Param2, class Param3, class Param4 >
1563 struct Splice_<Container,Param1,Param2,Param3,Param4,
1564 typename ::boost::disable_if<
1565 typename ::boost::mpl::or_<typename ::boost::is_same<Param3,void>::type,
1566 typename ::boost::mpl::not_<
1567 typename ::boost::is_same<Param4,void>::type>::type>::type >::type>
1568 : euml_action<Splice_<Container,Param1,Param2,Param3,Param4> >
1569 {
1570 template <class Event,class FSM,class STATE >
1571 struct state_action_result
1572 {
1573 typedef void type;
1574 };
1575 template <class EVT,class FSM,class SourceState,class TargetState>
1576 struct transition_action_result
1577 {
1578 typedef void type;
1579 };
1580 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1581
1582 template <class EVT,class FSM,class SourceState,class TargetState>
1583 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1584 {
1585 (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
1586 Param3()(evt,fsm,src,tgt));
1587 }
1588 template <class Event,class FSM,class STATE>
1589 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1590 {
1591 (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1592 Param3()(evt,fsm,state));
1593 }
1594 };
1595 template <class Container, class Param1, class Param2, class Param3, class Param4 >
1596 struct Splice_<Container,Param1,Param2,Param3,Param4,
1597 typename ::boost::disable_if<typename ::boost::is_same<Param4,void>::type >::type>
1598 : euml_action<Splice_<Container,Param1,Param2,Param3,Param4> >
1599 {
1600 template <class Event,class FSM,class STATE >
1601 struct state_action_result
1602 {
1603 typedef void type;
1604 };
1605 template <class EVT,class FSM,class SourceState,class TargetState>
1606 struct transition_action_result
1607 {
1608 typedef void type;
1609 };
1610 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1611
1612 template <class EVT,class FSM,class SourceState,class TargetState>
1613 void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1614 {
1615 (Container()(evt,fsm,src,tgt)).splice(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
1616 Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
1617 }
1618 template <class Event,class FSM,class STATE>
1619 void operator()(Event const& evt,FSM& fsm,STATE& state )const
1620 {
1621 (Container()(evt,fsm,state)).splice(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
1622 Param3()(evt,fsm,state),Param4()(evt,fsm,state));
1623 }
1624 };
1625 struct splice_tag {};
1626 struct Splice_Helper: proto::extends< proto::terminal<splice_tag>::type, Splice_Helper, boost::msm::sm_domain>
1627 {
1628 Splice_Helper(){}
1629 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1630 #ifdef BOOST_MSVC
1631 ,class Arg6
1632 #endif
1633 >
1634 struct In
1635 {
1636 typedef Splice_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
1637 };
1638 };
1639 Splice_Helper const splice_;
1640
1641 //template <class Container, class Param1, class Param2, class Param3, class Enable=void >
1642 //struct StringFind_ : euml_action<StringFind_<Container,Param1,Param2,Param3,Enable> >
1643 //{
1644 //};
1645 template <class Container,class Param1, class Param2, class Param3>
1646 struct StringFind_ : euml_action<StringFind_<Container,Param1,Param2,Param3> >
1647 {
1648 template <class Event,class FSM,class STATE >
1649 struct state_action_result
1650 {
1651 typedef typename remove_reference<
1652 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1653 };
1654 template <class EVT,class FSM,class SourceState,class TargetState>
1655 struct transition_action_result
1656 {
1657 typedef typename remove_reference<
1658 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1659 };
1660 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1661
1662 template <class EVT,class FSM,class SourceState,class TargetState>
1663 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1664 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1665 {
1666 return (Container()(evt,fsm,src,tgt)).
1667 find(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
1668 }
1669 template <class Event,class FSM,class STATE>
1670 typename state_action_result<Event,FSM,STATE>::type
1671 operator()(Event const& evt,FSM& fsm,STATE& state )const
1672 {
1673 return (Container()(evt,fsm,state)).
1674 find(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1675 }
1676 };
1677
1678 template <class Container,class Param1>
1679 struct StringFind_ < Container,Param1,void,void>
1680 : euml_action<StringFind_<Container,Param1,void,void> >
1681
1682 {
1683 template <class Event,class FSM,class STATE >
1684 struct state_action_result
1685 {
1686 typedef typename remove_reference<
1687 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1688 };
1689 template <class EVT,class FSM,class SourceState,class TargetState>
1690 struct transition_action_result
1691 {
1692 typedef typename remove_reference<
1693 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1694 };
1695 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1696
1697 template <class EVT,class FSM,class SourceState,class TargetState>
1698 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1699 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1700 {
1701 return (Container()(evt,fsm,src,tgt)).find(Param1()(evt,fsm,src,tgt));
1702 }
1703 template <class Event,class FSM,class STATE>
1704 typename state_action_result<Event,FSM,STATE>::type
1705 operator()(Event const& evt,FSM& fsm,STATE& state )const
1706 {
1707 return (Container()(evt,fsm,state)).find(Param1()(evt,fsm,state));
1708 }
1709 };
1710
1711 template <class Container,class Param1, class Param2>
1712 struct StringFind_ <Container,Param1,Param2,void>
1713 : euml_action<StringFind_<Container,Param1,Param2,void> >
1714 {
1715 template <class Event,class FSM,class STATE >
1716 struct state_action_result
1717 {
1718 typedef typename remove_reference<
1719 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1720 };
1721 template <class EVT,class FSM,class SourceState,class TargetState>
1722 struct transition_action_result
1723 {
1724 typedef typename remove_reference<
1725 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1726 };
1727 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1728
1729 template <class EVT,class FSM,class SourceState,class TargetState>
1730 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1731 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1732 {
1733 return (Container()(evt,fsm,src,tgt)).find(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1734 }
1735 template <class Event,class FSM,class STATE>
1736 typename state_action_result<Event,FSM,STATE>::type
1737 operator()(Event const& evt,FSM& fsm,STATE& state )const
1738 {
1739 return (Container()(evt,fsm,state)).find(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1740 }
1741 };
1742
1743 struct string_find_tag {};
1744 struct StringFind_Helper: proto::extends< proto::terminal<string_find_tag>::type, StringFind_Helper, boost::msm::sm_domain>
1745 {
1746 StringFind_Helper(){}
1747 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1748 #ifdef BOOST_MSVC
1749 ,class Arg6
1750 #endif
1751 >
1752 struct In
1753 {
1754 typedef StringFind_<Arg1,Arg2,Arg3,Arg4> type;
1755 };
1756 };
1757 StringFind_Helper const string_find_;
1758
1759 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
1760 struct StringRFind_ : euml_action<StringRFind_<Container,Param1,Param2,Param3,Enable> >
1761 {
1762 };
1763
1764 template <class Container,class Param1, class Param2, class Param3>
1765 struct StringRFind_ <
1766 Container,Param1,Param2,Param3,
1767 typename ::boost::enable_if<
1768 typename ::boost::is_same<Param2,void>::type
1769 >::type
1770 >
1771 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1772
1773 {
1774 template <class Event,class FSM,class STATE >
1775 struct state_action_result
1776 {
1777 typedef typename remove_reference<
1778 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1779 };
1780 template <class EVT,class FSM,class SourceState,class TargetState>
1781 struct transition_action_result
1782 {
1783 typedef typename remove_reference<
1784 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1785 };
1786 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1787
1788 template <class EVT,class FSM,class SourceState,class TargetState>
1789 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1790 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1791 {
1792 return (Container()(evt,fsm,src,tgt)).rfind(Param1()(evt,fsm,src,tgt));
1793 }
1794 template <class Event,class FSM,class STATE>
1795 typename state_action_result<Event,FSM,STATE>::type
1796 operator()(Event const& evt,FSM& fsm,STATE& state )const
1797 {
1798 return (Container()(evt,fsm,state)).rfind(Param1()(evt,fsm,state));
1799 }
1800 };
1801
1802 template <class Container,class Param1, class Param2, class Param3>
1803 struct StringRFind_ <
1804 Container,Param1,Param2,Param3,
1805 typename ::boost::enable_if<
1806 typename ::boost::mpl::and_<
1807 typename ::boost::is_same<Param3,void>::type,
1808 typename ::boost::mpl::not_<
1809 typename ::boost::is_same<Param2,void>::type
1810 >::type
1811 >::type
1812 >::type
1813 >
1814 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1815 {
1816 template <class Event,class FSM,class STATE >
1817 struct state_action_result
1818 {
1819 typedef typename remove_reference<
1820 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1821 };
1822 template <class EVT,class FSM,class SourceState,class TargetState>
1823 struct transition_action_result
1824 {
1825 typedef typename remove_reference<
1826 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1827 };
1828 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1829
1830 template <class EVT,class FSM,class SourceState,class TargetState>
1831 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1832 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1833 {
1834 return (Container()(evt,fsm,src,tgt)).rfind(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1835 }
1836 template <class Event,class FSM,class STATE>
1837 typename state_action_result<Event,FSM,STATE>::type
1838 operator()(Event const& evt,FSM& fsm,STATE& state )const
1839 {
1840 return (Container()(evt,fsm,state)).rfind(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1841 }
1842 };
1843
1844 template <class Container,class Param1, class Param2, class Param3>
1845 struct StringRFind_<
1846 Container,Param1,Param2,Param3,
1847 typename ::boost::disable_if<
1848 typename ::boost::is_same<Param3,void>::type
1849 >::type
1850 >
1851 : euml_action<StringRFind_<Container,Param1,Param2,Param3> >
1852 {
1853 template <class Event,class FSM,class STATE >
1854 struct state_action_result
1855 {
1856 typedef typename remove_reference<
1857 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1858 };
1859 template <class EVT,class FSM,class SourceState,class TargetState>
1860 struct transition_action_result
1861 {
1862 typedef typename remove_reference<
1863 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1864 };
1865 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1866
1867 template <class EVT,class FSM,class SourceState,class TargetState>
1868 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1869 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1870 {
1871 return (Container()(evt,fsm,src,tgt)).
1872 rfind(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
1873 }
1874 template <class Event,class FSM,class STATE>
1875 typename state_action_result<Event,FSM,STATE>::type
1876 operator()(Event const& evt,FSM& fsm,STATE& state )const
1877 {
1878 return (Container()(evt,fsm,state)).
1879 rfind(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1880 }
1881 };
1882
1883 struct string_rfind_tag {};
1884 struct StringRFind_Helper: proto::extends< proto::terminal<string_rfind_tag>::type, StringRFind_Helper, boost::msm::sm_domain>
1885 {
1886 StringRFind_Helper(){}
1887 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
1888 #ifdef BOOST_MSVC
1889 ,class Arg6
1890 #endif
1891 >
1892 struct In
1893 {
1894 typedef StringRFind_<Arg1,Arg2,Arg3,Arg4> type;
1895 };
1896 };
1897 StringRFind_Helper const string_rfind_;
1898
1899 template <class Container,class Param1, class Param2, class Param3>
1900 struct StringFindFirstOf_ : euml_action<StringFindFirstOf_<Container,Param1,Param2,Param3> >
1901 {
1902 template <class Event,class FSM,class STATE >
1903 struct state_action_result
1904 {
1905 typedef typename remove_reference<
1906 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1907 };
1908 template <class EVT,class FSM,class SourceState,class TargetState>
1909 struct transition_action_result
1910 {
1911 typedef typename remove_reference<
1912 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1913 };
1914 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1915
1916 template <class EVT,class FSM,class SourceState,class TargetState>
1917 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1918 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1919 {
1920 return (Container()(evt,fsm,src,tgt)).
1921 find_first_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
1922 }
1923 template <class Event,class FSM,class STATE>
1924 typename state_action_result<Event,FSM,STATE>::type
1925 operator()(Event const& evt,FSM& fsm,STATE& state )const
1926 {
1927 return (Container()(evt,fsm,state)).
1928 find_first_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
1929 }
1930 };
1931 template <class Container,class Param1>
1932 struct StringFindFirstOf_ <Container,Param1,void,void>
1933 : euml_action<StringFindFirstOf_<Container,Param1,void,void> >
1934 {
1935 template <class Event,class FSM,class STATE >
1936 struct state_action_result
1937 {
1938 typedef typename remove_reference<
1939 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1940 };
1941 template <class EVT,class FSM,class SourceState,class TargetState>
1942 struct transition_action_result
1943 {
1944 typedef typename remove_reference<
1945 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1946 };
1947 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1948
1949 template <class EVT,class FSM,class SourceState,class TargetState>
1950 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1951 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1952 {
1953 return (Container()(evt,fsm,src,tgt)).find_first_of(Param1()(evt,fsm,src,tgt));
1954 }
1955 template <class Event,class FSM,class STATE>
1956 typename state_action_result<Event,FSM,STATE>::type
1957 operator()(Event const& evt,FSM& fsm,STATE& state )const
1958 {
1959 return (Container()(evt,fsm,state)).find_first_of(Param1()(evt,fsm,state));
1960 }
1961 };
1962
1963 template <class Container,class Param1, class Param2>
1964 struct StringFindFirstOf_ <Container,Param1,Param2,void>
1965 : euml_action<StringFindFirstOf_<Container,Param1,Param2,void> >
1966 {
1967 template <class Event,class FSM,class STATE >
1968 struct state_action_result
1969 {
1970 typedef typename remove_reference<
1971 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
1972 };
1973 template <class EVT,class FSM,class SourceState,class TargetState>
1974 struct transition_action_result
1975 {
1976 typedef typename remove_reference<
1977 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
1978 };
1979 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
1980
1981 template <class EVT,class FSM,class SourceState,class TargetState>
1982 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
1983 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
1984 {
1985 return (Container()(evt,fsm,src,tgt)).find_first_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
1986 }
1987 template <class Event,class FSM,class STATE>
1988 typename state_action_result<Event,FSM,STATE>::type
1989 operator()(Event const& evt,FSM& fsm,STATE& state )const
1990 {
1991 return (Container()(evt,fsm,state)).find_first_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
1992 }
1993 };
1994
1995 struct string_find_first_of_tag {};
1996 struct StringFindFirstOf_Helper:
1997 proto::extends< proto::terminal<string_find_first_of_tag>::type, StringFindFirstOf_Helper, boost::msm::sm_domain>
1998 {
1999 StringFindFirstOf_Helper(){}
2000 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2001 #ifdef BOOST_MSVC
2002 ,class Arg6
2003 #endif
2004 >
2005 struct In
2006 {
2007 typedef StringFindFirstOf_<Arg1,Arg2,Arg3,Arg4> type;
2008 };
2009 };
2010 StringFindFirstOf_Helper const string_find_first_of_;
2011
2012 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2013 struct StringFindFirstNotOf_ : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3,Enable> >
2014 {
2015 };
2016
2017 template <class Container,class Param1, class Param2, class Param3>
2018 struct StringFindFirstNotOf_ <
2019 Container,Param1,Param2,Param3,
2020 typename ::boost::enable_if<
2021 typename ::boost::is_same<Param2,void>::type
2022 >::type
2023 >
2024 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2025
2026 {
2027 template <class Event,class FSM,class STATE >
2028 struct state_action_result
2029 {
2030 typedef typename remove_reference<
2031 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2032 };
2033 template <class EVT,class FSM,class SourceState,class TargetState>
2034 struct transition_action_result
2035 {
2036 typedef typename remove_reference<
2037 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2038 };
2039 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2040
2041 template <class EVT,class FSM,class SourceState,class TargetState>
2042 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2043 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2044 {
2045 return (Container()(evt,fsm,src,tgt)).find_first_not_of(Param1()(evt,fsm,src,tgt));
2046 }
2047 template <class Event,class FSM,class STATE>
2048 typename state_action_result<Event,FSM,STATE>::type
2049 operator()(Event const& evt,FSM& fsm,STATE& state )const
2050 {
2051 return (Container()(evt,fsm,state)).find_first_not_of(Param1()(evt,fsm,state));
2052 }
2053 };
2054
2055 template <class Container,class Param1, class Param2, class Param3>
2056 struct StringFindFirstNotOf_ <
2057 Container,Param1,Param2,Param3,
2058 typename ::boost::enable_if<
2059 typename ::boost::mpl::and_<
2060 typename ::boost::is_same<Param3,void>::type,
2061 typename ::boost::mpl::not_<
2062 typename ::boost::is_same<Param2,void>::type
2063 >::type
2064 >::type
2065 >::type
2066 >
2067 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2068 {
2069 template <class Event,class FSM,class STATE >
2070 struct state_action_result
2071 {
2072 typedef typename remove_reference<
2073 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2074 };
2075 template <class EVT,class FSM,class SourceState,class TargetState>
2076 struct transition_action_result
2077 {
2078 typedef typename remove_reference<
2079 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2080 };
2081 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2082
2083 template <class EVT,class FSM,class SourceState,class TargetState>
2084 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2085 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2086 {
2087 return (Container()(evt,fsm,src,tgt)).find_first_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
2088 }
2089 template <class Event,class FSM,class STATE>
2090 typename state_action_result<Event,FSM,STATE>::type
2091 operator()(Event const& evt,FSM& fsm,STATE& state )const
2092 {
2093 return (Container()(evt,fsm,state)).find_first_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
2094 }
2095 };
2096
2097 template <class Container,class Param1, class Param2, class Param3>
2098 struct StringFindFirstNotOf_<
2099 Container,Param1,Param2,Param3,
2100 typename ::boost::disable_if<
2101 typename ::boost::is_same<Param3,void>::type
2102 >::type
2103 >
2104 : euml_action<StringFindFirstNotOf_<Container,Param1,Param2,Param3> >
2105 {
2106 template <class Event,class FSM,class STATE >
2107 struct state_action_result
2108 {
2109 typedef typename remove_reference<
2110 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2111 };
2112 template <class EVT,class FSM,class SourceState,class TargetState>
2113 struct transition_action_result
2114 {
2115 typedef typename remove_reference<
2116 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2117 };
2118 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2119
2120 template <class EVT,class FSM,class SourceState,class TargetState>
2121 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2122 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2123 {
2124 return (Container()(evt,fsm,src,tgt)).
2125 find_first_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
2126 }
2127 template <class Event,class FSM,class STATE>
2128 typename state_action_result<Event,FSM,STATE>::type
2129 operator()(Event const& evt,FSM& fsm,STATE& state )const
2130 {
2131 return (Container()(evt,fsm,state)).
2132 find_first_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
2133 }
2134 };
2135
2136 struct string_find_first_not_of_tag {};
2137 struct StringFindFirstNotOf_Helper:
2138 proto::extends< proto::terminal<string_find_first_not_of_tag>::type, StringFindFirstNotOf_Helper, boost::msm::sm_domain>
2139 {
2140 StringFindFirstNotOf_Helper(){}
2141 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2142 #ifdef BOOST_MSVC
2143 ,class Arg6
2144 #endif
2145 >
2146 struct In
2147 {
2148 typedef StringFindFirstNotOf_<Arg1,Arg2,Arg3,Arg4> type;
2149 };
2150 };
2151 StringFindFirstNotOf_Helper const string_find_first_not_of_;
2152
2153 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2154 struct StringFindLastOf_ : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3,Enable> >
2155 {
2156 };
2157
2158 template <class Container,class Param1, class Param2, class Param3>
2159 struct StringFindLastOf_ <
2160 Container,Param1,Param2,Param3,
2161 typename ::boost::enable_if<
2162 typename ::boost::is_same<Param2,void>::type
2163 >::type
2164 >
2165 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2166
2167 {
2168 template <class Event,class FSM,class STATE >
2169 struct state_action_result
2170 {
2171 typedef typename remove_reference<
2172 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2173 };
2174 template <class EVT,class FSM,class SourceState,class TargetState>
2175 struct transition_action_result
2176 {
2177 typedef typename remove_reference<
2178 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2179 };
2180 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2181
2182 template <class EVT,class FSM,class SourceState,class TargetState>
2183 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2184 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2185 {
2186 return (Container()(evt,fsm,src,tgt)).find_last_of(Param1()(evt,fsm,src,tgt));
2187 }
2188 template <class Event,class FSM,class STATE>
2189 typename state_action_result<Event,FSM,STATE>::type
2190 operator()(Event const& evt,FSM& fsm,STATE& state )const
2191 {
2192 return (Container()(evt,fsm,state)).find_last_of(Param1()(evt,fsm,state));
2193 }
2194 };
2195
2196 template <class Container,class Param1, class Param2, class Param3>
2197 struct StringFindLastOf_ <
2198 Container,Param1,Param2,Param3,
2199 typename ::boost::enable_if<
2200 typename ::boost::mpl::and_<
2201 typename ::boost::is_same<Param3,void>::type,
2202 typename ::boost::mpl::not_<
2203 typename ::boost::is_same<Param2,void>::type
2204 >::type
2205 >::type
2206 >::type
2207 >
2208 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2209 {
2210 template <class Event,class FSM,class STATE >
2211 struct state_action_result
2212 {
2213 typedef typename remove_reference<
2214 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2215 };
2216 template <class EVT,class FSM,class SourceState,class TargetState>
2217 struct transition_action_result
2218 {
2219 typedef typename remove_reference<
2220 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2221 };
2222 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2223
2224 template <class EVT,class FSM,class SourceState,class TargetState>
2225 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2226 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2227 {
2228 return (Container()(evt,fsm,src,tgt)).find_last_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
2229 }
2230 template <class Event,class FSM,class STATE>
2231 typename state_action_result<Event,FSM,STATE>::type
2232 operator()(Event const& evt,FSM& fsm,STATE& state )const
2233 {
2234 return (Container()(evt,fsm,state)).find_last_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
2235 }
2236 };
2237
2238 template <class Container,class Param1, class Param2, class Param3>
2239 struct StringFindLastOf_<
2240 Container,Param1,Param2,Param3,
2241 typename ::boost::disable_if<
2242 typename ::boost::is_same<Param3,void>::type
2243 >::type
2244 >
2245 : euml_action<StringFindLastOf_<Container,Param1,Param2,Param3> >
2246 {
2247 template <class Event,class FSM,class STATE >
2248 struct state_action_result
2249 {
2250 typedef typename remove_reference<
2251 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2252 };
2253 template <class EVT,class FSM,class SourceState,class TargetState>
2254 struct transition_action_result
2255 {
2256 typedef typename remove_reference<
2257 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2258 };
2259 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2260
2261 template <class EVT,class FSM,class SourceState,class TargetState>
2262 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2263 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2264 {
2265 return (Container()(evt,fsm,src,tgt)).
2266 find_last_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
2267 }
2268 template <class Event,class FSM,class STATE>
2269 typename state_action_result<Event,FSM,STATE>::type
2270 operator()(Event const& evt,FSM& fsm,STATE& state )const
2271 {
2272 return (Container()(evt,fsm,state)).
2273 find_last_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
2274 }
2275 };
2276
2277 struct string_find_last_of_tag {};
2278 struct StringFindLastOf_Helper:
2279 proto::extends< proto::terminal<string_find_last_of_tag>::type, StringFindLastOf_Helper, boost::msm::sm_domain>
2280 {
2281 StringFindLastOf_Helper(){}
2282 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2283 #ifdef BOOST_MSVC
2284 ,class Arg6
2285 #endif
2286 >
2287 struct In
2288 {
2289 typedef StringFindLastOf_<Arg1,Arg2,Arg3,Arg4> type;
2290 };
2291 };
2292 StringFindLastOf_Helper const string_find_last_of_;
2293
2294 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
2295 struct StringFindLastNotOf_ : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3,Enable> >
2296 {
2297 };
2298
2299 template <class Container,class Param1, class Param2, class Param3>
2300 struct StringFindLastNotOf_ <
2301 Container,Param1,Param2,Param3,
2302 typename ::boost::enable_if<
2303 typename ::boost::is_same<Param2,void>::type
2304 >::type
2305 >
2306 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2307
2308 {
2309 template <class Event,class FSM,class STATE >
2310 struct state_action_result
2311 {
2312 typedef typename remove_reference<
2313 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2314 };
2315 template <class EVT,class FSM,class SourceState,class TargetState>
2316 struct transition_action_result
2317 {
2318 typedef typename remove_reference<
2319 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2320 };
2321 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2322
2323 template <class EVT,class FSM,class SourceState,class TargetState>
2324 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2325 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2326 {
2327 return (Container()(evt,fsm,src,tgt)).find_last_not_of(Param1()(evt,fsm,src,tgt));
2328 }
2329 template <class Event,class FSM,class STATE>
2330 typename state_action_result<Event,FSM,STATE>::type
2331 operator()(Event const& evt,FSM& fsm,STATE& state )const
2332 {
2333 return (Container()(evt,fsm,state)).find_last_not_of(Param1()(evt,fsm,state));
2334 }
2335 };
2336
2337 template <class Container,class Param1, class Param2, class Param3>
2338 struct StringFindLastNotOf_ <
2339 Container,Param1,Param2,Param3,
2340 typename ::boost::enable_if<
2341 typename ::boost::mpl::and_<
2342 typename ::boost::is_same<Param3,void>::type,
2343 typename ::boost::mpl::not_<
2344 typename ::boost::is_same<Param2,void>::type
2345 >::type
2346 >::type
2347 >::type
2348 >
2349 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2350 {
2351 template <class Event,class FSM,class STATE >
2352 struct state_action_result
2353 {
2354 typedef typename remove_reference<
2355 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2356 };
2357 template <class EVT,class FSM,class SourceState,class TargetState>
2358 struct transition_action_result
2359 {
2360 typedef typename remove_reference<
2361 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2362 };
2363 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2364
2365 template <class EVT,class FSM,class SourceState,class TargetState>
2366 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2367 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2368 {
2369 return (Container()(evt,fsm,src,tgt)).find_last_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
2370 }
2371 template <class Event,class FSM,class STATE>
2372 typename state_action_result<Event,FSM,STATE>::type
2373 operator()(Event const& evt,FSM& fsm,STATE& state )const
2374 {
2375 return (Container()(evt,fsm,state)).find_last_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
2376 }
2377 };
2378
2379 template <class Container,class Param1, class Param2, class Param3>
2380 struct StringFindLastNotOf_<
2381 Container,Param1,Param2,Param3,
2382 typename ::boost::disable_if<
2383 typename ::boost::is_same<Param3,void>::type
2384 >::type
2385 >
2386 : euml_action<StringFindLastNotOf_<Container,Param1,Param2,Param3> >
2387 {
2388 template <class Event,class FSM,class STATE >
2389 struct state_action_result
2390 {
2391 typedef typename remove_reference<
2392 typename get_result_type2<Container,Event,FSM,STATE>::type>::type::size_type type;
2393 };
2394 template <class EVT,class FSM,class SourceState,class TargetState>
2395 struct transition_action_result
2396 {
2397 typedef typename remove_reference<
2398 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type::size_type type;
2399 };
2400 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2401
2402 template <class EVT,class FSM,class SourceState,class TargetState>
2403 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2404 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2405 {
2406 return (Container()(evt,fsm,src,tgt)).
2407 find_last_not_of(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
2408 }
2409 template <class Event,class FSM,class STATE>
2410 typename state_action_result<Event,FSM,STATE>::type
2411 operator()(Event const& evt,FSM& fsm,STATE& state )const
2412 {
2413 return (Container()(evt,fsm,state)).
2414 find_last_not_of(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
2415 }
2416 };
2417
2418 struct string_find_last_not_of_tag {};
2419 struct StringFindLastNotOf_Helper:
2420 proto::extends< proto::terminal<string_find_last_of_tag>::type, StringFindLastNotOf_Helper, boost::msm::sm_domain>
2421 {
2422 StringFindLastNotOf_Helper(){}
2423 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2424 #ifdef BOOST_MSVC
2425 ,class Arg6
2426 #endif
2427 >
2428 struct In
2429 {
2430 typedef StringFindLastNotOf_<Arg1,Arg2,Arg3,Arg4> type;
2431 };
2432 };
2433 StringFindLastNotOf_Helper const string_find_last_not_of_;
2434
2435 template <class Container>
2436 struct Npos_ : euml_action<Npos_<Container> >
2437 {
2438 Npos_(){}
2439 template <class Event,class FSM,class STATE >
2440 struct state_action_result
2441 {
2442 typedef typename Container::size_type type;
2443 };
2444 template <class EVT,class FSM,class SourceState,class TargetState>
2445 struct transition_action_result
2446 {
2447 typedef typename Container::size_type type;
2448 };
2449 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2450
2451 template <class EVT,class FSM,class SourceState,class TargetState>
2452 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2453 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2454 {
2455 return Container::npos;
2456 }
2457 template <class Event,class FSM,class STATE>
2458 typename state_action_result<Event,FSM,STATE>::type
2459 operator()(Event const& evt,FSM& fsm,STATE& state )const
2460 {
2461 return Container::npos;
2462 }
2463 };
2464
2465 // version for 2 parameters
2466 template <class Container, class Param1, class Param2>
2467 struct Associative_Erase_ : euml_action<Associative_Erase_<Container,Param1,Param2> >
2468 {
2469 template <class Event,class FSM,class STATE >
2470 struct state_action_result
2471 {
2472 typedef void type;
2473 };
2474 template <class EVT,class FSM,class SourceState,class TargetState>
2475 struct transition_action_result
2476 {
2477 typedef void type;
2478 };
2479 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2480
2481 template <class EVT,class FSM,class SourceState,class TargetState>
2482 typename ::boost::enable_if<
2483 typename ::boost::mpl::has_key<
2484 typename Container::tag_type,action_tag>::type,
2485 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2486 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2487 {
2488 (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
2489 }
2490 template <class Event,class FSM,class STATE>
2491 typename ::boost::enable_if<
2492 typename ::boost::mpl::has_key<
2493 typename Container::tag_type,state_action_tag>::type,
2494 typename state_action_result<Event,FSM,STATE>::type >::type
2495 operator()(Event const& evt,FSM& fsm,STATE& state )const
2496 {
2497 (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
2498 }
2499 };
2500 // version for 1 parameter
2501 template <class Container, class Param1>
2502 struct Associative_Erase_ < Container,Param1,void>
2503 : euml_action<Associative_Erase_<Container,Param1,void> >
2504 {
2505 // return value will actually not be correct for set::erase(it), should be void
2506 // but it's ok as nobody should call an inexistent return type
2507 template <class Event,class FSM,class STATE >
2508 struct state_action_result
2509 {
2510 typedef typename get_size_type<
2511 typename ::boost::remove_reference<
2512 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
2513 };
2514 template <class EVT,class FSM,class SourceState,class TargetState>
2515 struct transition_action_result
2516 {
2517 typedef typename get_size_type<
2518 typename ::boost::remove_reference<
2519 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2520 };
2521 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2522
2523 // version for transition + param is an iterator
2524 template <class EVT,class FSM,class SourceState,class TargetState>
2525 typename ::boost::enable_if<
2526 typename ::boost::mpl::and_<
2527 typename ::boost::mpl::has_key<
2528 typename Container::tag_type,action_tag>::type,
2529 typename has_iterator_category<
2530 typename Param1::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
2531 >::type
2532 >::type,
2533 void
2534 >::type
2535 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2536 {
2537 (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
2538 }
2539
2540 // version for state action + param is an iterator
2541 template <class Event,class FSM,class STATE>
2542 typename ::boost::enable_if<
2543 typename ::boost::mpl::and_<
2544 typename ::boost::mpl::has_key<
2545 typename Container::tag_type,state_action_tag>::type,
2546 typename has_iterator_category<
2547 typename Param1::template state_action_result<Event,FSM,STATE>::type
2548 >::type
2549 >::type,
2550 void
2551 >::type
2552 operator()(Event const& evt,FSM& fsm,STATE& state )const
2553 {
2554 (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
2555 }
2556
2557 // version for transition + param not an iterator
2558 template <class EVT,class FSM,class SourceState,class TargetState>
2559 typename ::boost::enable_if<
2560 typename ::boost::mpl::and_<
2561 typename ::boost::mpl::has_key<
2562 typename Container::tag_type,action_tag>::type,
2563 typename ::boost::mpl::not_<
2564 typename has_iterator_category<
2565 typename Param1::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
2566 >::type
2567 >::type
2568 >::type,
2569 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
2570 >::type
2571 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2572 {
2573 return (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
2574 }
2575
2576 // version for state action + param not an iterator
2577 template <class Event,class FSM,class STATE>
2578 typename ::boost::enable_if<
2579 typename ::boost::mpl::and_<
2580 typename ::boost::mpl::has_key<
2581 typename Container::tag_type,state_action_tag>::type,
2582 typename ::boost::mpl::not_<
2583 typename has_iterator_category<
2584 typename Param1::template state_action_result<Event,FSM,STATE>::type
2585 >::type
2586 >::type
2587 >::type,
2588 typename state_action_result<Event,FSM,STATE>::type
2589 >::type
2590 operator()(Event const& evt,FSM& fsm,STATE& state )const
2591 {
2592 return (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
2593 }
2594 };
2595
2596 struct associative_erase_tag {};
2597 struct Associative_Erase_Helper: proto::extends< proto::terminal<associative_erase_tag>::type, Associative_Erase_Helper, boost::msm::sm_domain>
2598 {
2599 Associative_Erase_Helper(){}
2600 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2601 #ifdef BOOST_MSVC
2602 ,class Arg6
2603 #endif
2604 >
2605 struct In
2606 {
2607 typedef Associative_Erase_<Arg1,Arg2,Arg3> type;
2608 };
2609 };
2610 Associative_Erase_Helper const associative_erase_;
2611
2612
2613 template <class T, class Param>
2614 struct Associative_Find_ : euml_action<Associative_Find_<T,Param> >
2615 {
2616 template <class Event,class FSM,class STATE >
2617 struct state_action_result
2618 {
2619 typedef typename get_iterator<
2620 typename ::boost::remove_reference<
2621 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2622 };
2623 template <class EVT,class FSM,class SourceState,class TargetState>
2624 struct transition_action_result
2625 {
2626 typedef typename get_iterator<
2627 typename ::boost::remove_reference<
2628 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2629 };
2630 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2631
2632 template <class EVT,class FSM,class SourceState,class TargetState>
2633 typename ::boost::enable_if<
2634 typename ::boost::mpl::has_key<
2635 typename T::tag_type,action_tag>::type,
2636 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2637 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2638 {
2639 return (T()(evt,fsm,src,tgt)).find(Param()(evt,fsm,src,tgt));
2640 }
2641 template <class Event,class FSM,class STATE>
2642 typename ::boost::enable_if<
2643 typename ::boost::mpl::has_key<
2644 typename T::tag_type,state_action_tag>::type,
2645 typename state_action_result<Event,FSM,STATE>::type >::type
2646 operator()(Event const& evt,FSM& fsm,STATE& state )const
2647 {
2648 return (T()(evt,fsm,state)).find(Param()(evt,fsm,state));
2649 }
2650 };
2651
2652 struct associative_find_tag {};
2653 struct Associative_Find_Helper: proto::extends< proto::terminal<associative_find_tag>::type, Associative_Find_Helper, boost::msm::sm_domain>
2654 {
2655 Associative_Find_Helper(){}
2656 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2657 #ifdef BOOST_MSVC
2658 ,class Arg6
2659 #endif
2660 >
2661 struct In
2662 {
2663 typedef Associative_Find_<Arg1,Arg2> type;
2664 };
2665 };
2666 Associative_Find_Helper const associative_find_;
2667
2668 template <class Container,class Param>
2669 struct AssociativeCount_ : euml_action<AssociativeCount_<Container,Param> >
2670 {
2671 template <class Event,class FSM,class STATE >
2672 struct state_action_result
2673 {
2674 typedef typename get_size_type<
2675 typename ::boost::remove_reference<
2676 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
2677 };
2678 template <class EVT,class FSM,class SourceState,class TargetState>
2679 struct transition_action_result
2680 {
2681 typedef typename get_size_type<
2682 typename ::boost::remove_reference<
2683 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2684 };
2685 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2686
2687 template <class EVT,class FSM,class SourceState,class TargetState>
2688 typename ::boost::enable_if<
2689 typename ::boost::mpl::has_key<
2690 typename Container::tag_type,action_tag>::type,
2691 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2692 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2693 {
2694 return (Container()(evt,fsm,src,tgt)).count(Param()(evt,fsm,src,tgt));
2695 }
2696 template <class Event,class FSM,class STATE>
2697 typename ::boost::enable_if<
2698 typename ::boost::mpl::has_key<
2699 typename Container::tag_type,state_action_tag>::type,
2700 typename state_action_result<Event,FSM,STATE>::type >::type
2701 operator()(Event const& evt,FSM& fsm,STATE& state )const
2702 {
2703 return (Container()(evt,fsm,state)).count(Param()(evt,fsm,state));
2704 }
2705 };
2706 struct associative_count_tag {};
2707 struct AssociativeCount_Helper: proto::extends< proto::terminal<associative_count_tag>::type, AssociativeCount_Helper, boost::msm::sm_domain>
2708 {
2709 AssociativeCount_Helper(){}
2710 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2711 #ifdef BOOST_MSVC
2712 ,class Arg6
2713 #endif
2714 >
2715 struct In
2716 {
2717 typedef AssociativeCount_<Arg1,Arg2> type;
2718 };
2719 };
2720 AssociativeCount_Helper const associative_count_;
2721
2722 template <class T, class Param>
2723 struct Associative_Lower_Bound_ : euml_action<Associative_Lower_Bound_<T,Param> >
2724 {
2725 template <class Event,class FSM,class STATE >
2726 struct state_action_result
2727 {
2728 typedef typename get_iterator<
2729 typename ::boost::remove_reference<
2730 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2731 };
2732 template <class EVT,class FSM,class SourceState,class TargetState>
2733 struct transition_action_result
2734 {
2735 typedef typename get_iterator<
2736 typename ::boost::remove_reference<
2737 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2738 };
2739 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2740
2741 template <class EVT,class FSM,class SourceState,class TargetState>
2742 typename ::boost::enable_if<
2743 typename ::boost::mpl::has_key<
2744 typename T::tag_type,action_tag>::type,
2745 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2746 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2747 {
2748 return (T()(evt,fsm,src,tgt)).lower_bound(Param()(evt,fsm,src,tgt));
2749 }
2750 template <class Event,class FSM,class STATE>
2751 typename ::boost::enable_if<
2752 typename ::boost::mpl::has_key<
2753 typename T::tag_type,state_action_tag>::type,
2754 typename state_action_result<Event,FSM,STATE>::type >::type
2755 operator()(Event const& evt,FSM& fsm,STATE& state )const
2756 {
2757 return (T()(evt,fsm,state)).lower_bound(Param()(evt,fsm,state));
2758 }
2759 };
2760
2761 struct associative_lower_bound_tag {};
2762 struct Associative_Lower_Bound_Helper: proto::extends< proto::terminal<associative_lower_bound_tag>::type,
2763 Associative_Lower_Bound_Helper, boost::msm::sm_domain>
2764 {
2765 Associative_Lower_Bound_Helper(){}
2766 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2767 #ifdef BOOST_MSVC
2768 ,class Arg6
2769 #endif
2770 >
2771 struct In
2772 {
2773 typedef Associative_Lower_Bound_<Arg1,Arg2> type;
2774 };
2775 };
2776 Associative_Lower_Bound_Helper const associative_lower_bound_;
2777
2778 template <class T, class Param>
2779 struct Associative_Upper_Bound_ : euml_action<Associative_Upper_Bound_<T,Param> >
2780 {
2781 template <class Event,class FSM,class STATE >
2782 struct state_action_result
2783 {
2784 typedef typename get_iterator<
2785 typename ::boost::remove_reference<
2786 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2787 };
2788 template <class EVT,class FSM,class SourceState,class TargetState>
2789 struct transition_action_result
2790 {
2791 typedef typename get_iterator<
2792 typename ::boost::remove_reference<
2793 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2794 };
2795 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2796
2797 template <class EVT,class FSM,class SourceState,class TargetState>
2798 typename ::boost::enable_if<
2799 typename ::boost::mpl::has_key<
2800 typename T::tag_type,action_tag>::type,
2801 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2802 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2803 {
2804 return (T()(evt,fsm,src,tgt)).upper_bound(Param()(evt,fsm,src,tgt));
2805 }
2806 template <class Event,class FSM,class STATE>
2807 typename ::boost::enable_if<
2808 typename ::boost::mpl::has_key<
2809 typename T::tag_type,state_action_tag>::type,
2810 typename state_action_result<Event,FSM,STATE>::type >::type
2811 operator()(Event const& evt,FSM& fsm,STATE& state )const
2812 {
2813 return (T()(evt,fsm,state)).upper_bound(Param()(evt,fsm,state));
2814 }
2815 };
2816
2817 struct associative_upper_bound_tag {};
2818 struct Associative_Upper_Bound_Helper: proto::extends< proto::terminal<associative_upper_bound_tag>::type,
2819 Associative_Upper_Bound_Helper, boost::msm::sm_domain>
2820 {
2821 Associative_Upper_Bound_Helper(){}
2822 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2823 #ifdef BOOST_MSVC
2824 ,class Arg6
2825 #endif
2826 >
2827 struct In
2828 {
2829 typedef Associative_Upper_Bound_<Arg1,Arg2> type;
2830 };
2831 };
2832 Associative_Upper_Bound_Helper const associative_upper_bound_;
2833
2834 template <class T>
2835 struct First_ : euml_action<First_<T> >
2836 {
2837 template <class Event,class FSM,class STATE >
2838 struct state_action_result
2839 {
2840 typedef typename get_first_type<
2841 typename ::boost::remove_reference<
2842 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2843 };
2844 template <class EVT,class FSM,class SourceState,class TargetState>
2845 struct transition_action_result
2846 {
2847 typedef typename get_first_type<
2848 typename ::boost::remove_reference<
2849 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2850 };
2851 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2852
2853 template <class EVT,class FSM,class SourceState,class TargetState>
2854 typename ::boost::enable_if<
2855 typename ::boost::mpl::has_key<
2856 typename T::tag_type,action_tag>::type,
2857 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2858 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2859 {
2860 return (T()(evt,fsm,src,tgt)).first;
2861 }
2862 template <class Event,class FSM,class STATE>
2863 typename ::boost::enable_if<
2864 typename ::boost::mpl::has_key<
2865 typename T::tag_type,state_action_tag>::type,
2866 typename state_action_result<Event,FSM,STATE>::type >::type
2867 operator()(Event const& evt,FSM& fsm,STATE& state )const
2868 {
2869 return (T()(evt,fsm,state)).first;
2870 }
2871 };
2872
2873 struct first_tag {};
2874 struct First_Helper: proto::extends< proto::terminal<first_tag>::type, First_Helper, boost::msm::sm_domain>
2875 {
2876 First_Helper(){}
2877 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2878 #ifdef BOOST_MSVC
2879 ,class Arg6
2880 #endif
2881 >
2882 struct In
2883 {
2884 typedef First_<Arg1> type;
2885 };
2886 };
2887 First_Helper const first_;
2888
2889 template <class T>
2890 struct Second_ : euml_action<Second_<T> >
2891 {
2892 template <class Event,class FSM,class STATE >
2893 struct state_action_result
2894 {
2895 typedef typename get_second_type<
2896 typename ::boost::remove_reference<
2897 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
2898 };
2899 template <class EVT,class FSM,class SourceState,class TargetState>
2900 struct transition_action_result
2901 {
2902 typedef typename get_second_type<
2903 typename ::boost::remove_reference<
2904 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
2905 };
2906 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2907
2908 template <class EVT,class FSM,class SourceState,class TargetState>
2909 typename ::boost::enable_if<
2910 typename ::boost::mpl::has_key<
2911 typename T::tag_type,action_tag>::type,
2912 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2913 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2914 {
2915 return (T()(evt,fsm,src,tgt)).second;
2916 }
2917 template <class Event,class FSM,class STATE>
2918 typename ::boost::enable_if<
2919 typename ::boost::mpl::has_key<
2920 typename T::tag_type,state_action_tag>::type,
2921 typename state_action_result<Event,FSM,STATE>::type >::type
2922 operator()(Event const& evt,FSM& fsm,STATE& state )const
2923 {
2924 return (T()(evt,fsm,state)).second;
2925 }
2926 };
2927
2928 struct second_tag {};
2929 struct Second_Helper: proto::extends< proto::terminal<second_tag>::type, Second_Helper, boost::msm::sm_domain>
2930 {
2931 Second_Helper(){}
2932 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2933 #ifdef BOOST_MSVC
2934 ,class Arg6
2935 #endif
2936 >
2937 struct In
2938 {
2939 typedef Second_<Arg1> type;
2940 };
2941 };
2942 Second_Helper const second_;
2943
2944 template <class T, class Param>
2945 struct Associative_Equal_Range_ : euml_action<Associative_Equal_Range_<T,Param> >
2946 {
2947 template <class Event,class FSM,class STATE >
2948 struct state_action_result
2949 {
2950 typedef std::pair<
2951 typename get_iterator<
2952 typename ::boost::remove_reference<
2953 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type,
2954 typename get_iterator<
2955 typename ::boost::remove_reference<
2956 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type > type;
2957 };
2958 template <class EVT,class FSM,class SourceState,class TargetState>
2959 struct transition_action_result
2960 {
2961 typedef std::pair<
2962 typename get_iterator<
2963 typename ::boost::remove_reference<
2964 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type,
2965 typename get_iterator<
2966 typename ::boost::remove_reference<
2967 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type > type;
2968 };
2969 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
2970
2971 template <class EVT,class FSM,class SourceState,class TargetState>
2972 typename ::boost::enable_if<
2973 typename ::boost::mpl::has_key<
2974 typename T::tag_type,action_tag>::type,
2975 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
2976 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
2977 {
2978 return (T()(evt,fsm,src,tgt)).equal_range(Param()(evt,fsm,src,tgt));
2979 }
2980 template <class Event,class FSM,class STATE>
2981 typename ::boost::enable_if<
2982 typename ::boost::mpl::has_key<
2983 typename T::tag_type,state_action_tag>::type,
2984 typename state_action_result<Event,FSM,STATE>::type >::type
2985 operator()(Event const& evt,FSM& fsm,STATE& state )const
2986 {
2987 return (T()(evt,fsm,state)).equal_range(Param()(evt,fsm,state));
2988 }
2989 };
2990
2991 struct associative_equal_range_tag {};
2992 struct Associative_Equal_Range_Helper: proto::extends< proto::terminal<associative_equal_range_tag>::type,
2993 Associative_Equal_Range_Helper, boost::msm::sm_domain>
2994 {
2995 Associative_Equal_Range_Helper(){}
2996 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
2997 #ifdef BOOST_MSVC
2998 ,class Arg6
2999 #endif
3000 >
3001 struct In
3002 {
3003 typedef Associative_Equal_Range_<Arg1,Arg2> type;
3004 };
3005 };
3006 Associative_Equal_Range_Helper const associative_equal_range_;
3007
3008 template <class Container,class Param1, class Param2>
3009 struct Substr_ : euml_action<Substr_<Container,Param1,Param2> >
3010 {
3011 template <class Event,class FSM,class STATE >
3012 struct state_action_result
3013 {
3014 typedef typename remove_reference<
3015 typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3016 };
3017 template <class EVT,class FSM,class SourceState,class TargetState>
3018 struct transition_action_result
3019 {
3020 typedef typename remove_reference<
3021 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3022 };
3023 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3024
3025 template <class EVT,class FSM,class SourceState,class TargetState>
3026 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3027 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3028 {
3029 return (Container()(evt,fsm,src,tgt)).
3030 substr(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3031 }
3032 template <class Event,class FSM,class STATE>
3033 typename state_action_result<Event,FSM,STATE>::type
3034 operator()(Event const& evt,FSM& fsm,STATE& state )const
3035 {
3036 return (Container()(evt,fsm,state)).
3037 substr(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3038 }
3039 };
3040 template <class Container>
3041 struct Substr_ <Container,void,void>
3042 : euml_action<Substr_<Container,void,void> >
3043
3044 {
3045 template <class Event,class FSM,class STATE >
3046 struct state_action_result
3047 {
3048 typedef typename remove_reference<
3049 typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3050 };
3051 template <class EVT,class FSM,class SourceState,class TargetState>
3052 struct transition_action_result
3053 {
3054 typedef typename remove_reference<
3055 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3056 };
3057 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3058
3059 template <class EVT,class FSM,class SourceState,class TargetState>
3060 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3061 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3062 {
3063 return (Container()(evt,fsm,src,tgt)).substr();
3064 }
3065 template <class Event,class FSM,class STATE>
3066 typename state_action_result<Event,FSM,STATE>::type
3067 operator()(Event const& evt,FSM& fsm,STATE& state )const
3068 {
3069 return (Container()(evt,fsm,state)).substr();
3070 }
3071 };
3072
3073 template <class Container,class Param1>
3074 struct Substr_ < Container,Param1,void>
3075 : euml_action<Substr_<Container,Param1,void> >
3076 {
3077 template <class Event,class FSM,class STATE >
3078 struct state_action_result
3079 {
3080 typedef typename remove_reference<
3081 typename get_result_type2<Container,Event,FSM,STATE>::type>::type type;
3082 };
3083 template <class EVT,class FSM,class SourceState,class TargetState>
3084 struct transition_action_result
3085 {
3086 typedef typename remove_reference<
3087 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type type;
3088 };
3089 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3090
3091 template <class EVT,class FSM,class SourceState,class TargetState>
3092 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3093 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3094 {
3095 return (Container()(evt,fsm,src,tgt)).substr(Param1()(evt,fsm,src,tgt));
3096 }
3097 template <class Event,class FSM,class STATE>
3098 typename state_action_result<Event,FSM,STATE>::type
3099 operator()(Event const& evt,FSM& fsm,STATE& state )const
3100 {
3101 return (Container()(evt,fsm,state)).substr(Param1()(evt,fsm,state));
3102 }
3103 };
3104 struct substr_tag {};
3105 struct Substr_Helper: proto::extends< proto::terminal<substr_tag>::type, Substr_Helper, boost::msm::sm_domain>
3106 {
3107 Substr_Helper(){}
3108 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3109 #ifdef BOOST_MSVC
3110 ,class Arg6
3111 #endif
3112 >
3113 struct In
3114 {
3115 typedef Substr_<Arg1,Arg2,Arg3> type;
3116 };
3117 };
3118 Substr_Helper const substr_;
3119
3120 template <class Container, class Param1, class Param2, class Param3, class Param4 >
3121 struct StringCompare_ : euml_action<StringCompare_<Container,Param1,Param2,Param3,Param4> >
3122 {
3123 template <class Event,class FSM,class STATE >
3124 struct state_action_result
3125 {
3126 typedef int type;
3127 };
3128 template <class EVT,class FSM,class SourceState,class TargetState>
3129 struct transition_action_result
3130 {
3131 typedef int type;
3132 };
3133 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3134
3135 template <class EVT,class FSM,class SourceState,class TargetState>
3136 typename ::boost::enable_if<
3137 typename ::boost::mpl::has_key<
3138 typename Container::tag_type,action_tag>::type,
3139 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3140 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3141 {
3142 return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3143 Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
3144 }
3145 template <class Event,class FSM,class STATE>
3146 typename ::boost::enable_if<
3147 typename ::boost::mpl::has_key<
3148 typename Container::tag_type,state_action_tag>::type,
3149 typename state_action_result<Event,FSM,STATE>::type >::type
3150 operator()(Event const& evt,FSM& fsm,STATE& state )const
3151 {
3152 return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3153 Param3()(evt,fsm,state),Param4()(evt,fsm,state));
3154 }
3155 };
3156 template <class Container, class Param1 >
3157 struct StringCompare_<Container,Param1,void,void,void>
3158 : euml_action<StringCompare_<Container,Param1,void,void,void> >
3159 {
3160 template <class Event,class FSM,class STATE >
3161 struct state_action_result
3162 {
3163 typedef int type;
3164 };
3165 template <class EVT,class FSM,class SourceState,class TargetState>
3166 struct transition_action_result
3167 {
3168 typedef int type;
3169 };
3170 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3171
3172 template <class EVT,class FSM,class SourceState,class TargetState>
3173 typename ::boost::enable_if<
3174 typename ::boost::mpl::has_key<
3175 typename Container::tag_type,action_tag>::type,
3176 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3177 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3178 {
3179 return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt));
3180 }
3181 template <class Event,class FSM,class STATE>
3182 typename ::boost::enable_if<
3183 typename ::boost::mpl::has_key<
3184 typename Container::tag_type,state_action_tag>::type,
3185 typename state_action_result<Event,FSM,STATE>::type >::type
3186 operator()(Event const& evt,FSM& fsm,STATE& state )const
3187 {
3188 return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state));
3189 }
3190 };
3191
3192 template <class Container, class Param1, class Param2>
3193 struct StringCompare_<Container,Param1,Param2,void,void>
3194 : euml_action<StringCompare_<Container,Param1,Param2,void,void> >
3195 {
3196 template <class Event,class FSM,class STATE >
3197 struct state_action_result
3198 {
3199 typedef int type;
3200 };
3201 template <class EVT,class FSM,class SourceState,class TargetState>
3202 struct transition_action_result
3203 {
3204 typedef int type;
3205 };
3206 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3207
3208 template <class EVT,class FSM,class SourceState,class TargetState>
3209 typename ::boost::enable_if<
3210 typename ::boost::mpl::has_key<
3211 typename Container::tag_type,action_tag>::type,
3212 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3213 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3214 {
3215 return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3216 }
3217 template <class Event,class FSM,class STATE>
3218 typename ::boost::enable_if<
3219 typename ::boost::mpl::has_key<
3220 typename Container::tag_type,state_action_tag>::type,
3221 typename state_action_result<Event,FSM,STATE>::type >::type
3222 operator()(Event const& evt,FSM& fsm,STATE& state )const
3223 {
3224 return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3225 }
3226 };
3227
3228 template <class Container, class Param1, class Param2, class Param3 >
3229 struct StringCompare_<Container,Param1,Param2,Param3,void>
3230 : euml_action<StringCompare_<Container,Param1,Param2,Param3,void> >
3231 {
3232 template <class Event,class FSM,class STATE >
3233 struct state_action_result
3234 {
3235 typedef int type;
3236 };
3237 template <class EVT,class FSM,class SourceState,class TargetState>
3238 struct transition_action_result
3239 {
3240 typedef int type;
3241 };
3242 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3243
3244 template <class EVT,class FSM,class SourceState,class TargetState>
3245 typename ::boost::enable_if<
3246 typename ::boost::mpl::has_key<
3247 typename Container::tag_type,action_tag>::type,
3248 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3249 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3250 {
3251 return (Container()(evt,fsm,src,tgt)).compare(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3252 Param3()(evt,fsm,src,tgt));
3253 }
3254 template <class Event,class FSM,class STATE>
3255 typename ::boost::enable_if<
3256 typename ::boost::mpl::has_key<
3257 typename Container::tag_type,state_action_tag>::type,
3258 typename state_action_result<Event,FSM,STATE>::type >::type
3259 operator()(Event const& evt,FSM& fsm,STATE& state )const
3260 {
3261 return (Container()(evt,fsm,state)).compare(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3262 Param3()(evt,fsm,state));
3263 }
3264 };
3265
3266 struct string_compare_tag {};
3267 struct StringCompare_Helper: proto::extends< proto::terminal<string_compare_tag>::type, StringCompare_Helper, boost::msm::sm_domain>
3268 {
3269 StringCompare_Helper(){}
3270 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3271 #ifdef BOOST_MSVC
3272 ,class Arg6
3273 #endif
3274 >
3275 struct In
3276 {
3277 typedef StringCompare_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3278 };
3279 };
3280 StringCompare_Helper const string_compare_;
3281
3282 template <class Container, class Param1, class Param2, class Param3 >
3283 struct Append_ : euml_action<Append_<Container,Param1,Param2,Param3> >
3284 {
3285 template <class Event,class FSM,class STATE >
3286 struct state_action_result
3287 {
3288 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3289 };
3290 template <class EVT,class FSM,class SourceState,class TargetState>
3291 struct transition_action_result
3292 {
3293 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3294 };
3295 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3296
3297 template <class EVT,class FSM,class SourceState,class TargetState>
3298 typename ::boost::enable_if<
3299 typename ::boost::mpl::has_key<
3300 typename Container::tag_type,action_tag>::type,
3301 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3302 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3303 {
3304 return (Container()(evt,fsm,src,tgt)).append (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3305 Param3()(evt,fsm,src,tgt));
3306 }
3307 template <class Event,class FSM,class STATE>
3308 typename ::boost::enable_if<
3309 typename ::boost::mpl::has_key<
3310 typename Container::tag_type,state_action_tag>::type,
3311 typename state_action_result<Event,FSM,STATE>::type >::type
3312 operator()(Event const& evt,FSM& fsm,STATE& state )const
3313 {
3314 return (Container()(evt,fsm,state)).append (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3315 Param3()(evt,fsm,state));
3316 }
3317 };
3318 template <class Container, class Param1>
3319 struct Append_<Container,Param1,void,void>
3320 : euml_action<Append_<Container,Param1,void,void> >
3321 {
3322 template <class Event,class FSM,class STATE >
3323 struct state_action_result
3324 {
3325 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3326 };
3327 template <class EVT,class FSM,class SourceState,class TargetState>
3328 struct transition_action_result
3329 {
3330 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3331 };
3332 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3333
3334 template <class EVT,class FSM,class SourceState,class TargetState>
3335 typename ::boost::enable_if<
3336 typename ::boost::mpl::has_key<
3337 typename Container::tag_type,action_tag>::type,
3338 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3339 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3340 {
3341 return (Container()(evt,fsm,src,tgt)).append(Param1()(evt,fsm,src,tgt));
3342 }
3343 template <class Event,class FSM,class STATE>
3344 typename ::boost::enable_if<
3345 typename ::boost::mpl::has_key<
3346 typename Container::tag_type,state_action_tag>::type,
3347 typename state_action_result<Event,FSM,STATE>::type >::type
3348 operator()(Event const& evt,FSM& fsm,STATE& state )const
3349 {
3350 return (Container()(evt,fsm,state)).append(Param1()(evt,fsm,state));
3351 }
3352 };
3353
3354 template <class Container, class Param1, class Param2 >
3355 struct Append_<Container,Param1,Param2,void>
3356 : euml_action<Append_<Container,Param1,Param2,void> >
3357 {
3358 template <class Event,class FSM,class STATE >
3359 struct state_action_result
3360 {
3361 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3362 };
3363 template <class EVT,class FSM,class SourceState,class TargetState>
3364 struct transition_action_result
3365 {
3366 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3367 };
3368 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3369
3370 template <class EVT,class FSM,class SourceState,class TargetState>
3371 typename ::boost::enable_if<
3372 typename ::boost::mpl::has_key<
3373 typename Container::tag_type,action_tag>::type,
3374 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3375 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3376 {
3377 return (Container()(evt,fsm,src,tgt)).append(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3378 }
3379 template <class Event,class FSM,class STATE>
3380 typename ::boost::enable_if<
3381 typename ::boost::mpl::has_key<
3382 typename Container::tag_type,state_action_tag>::type,
3383 typename state_action_result<Event,FSM,STATE>::type >::type
3384 operator()(Event const& evt,FSM& fsm,STATE& state )const
3385 {
3386 return (Container()(evt,fsm,state)).append(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3387 }
3388 };
3389
3390 struct append_tag {};
3391 struct Append_Helper: proto::extends< proto::terminal<append_tag>::type, Append_Helper, boost::msm::sm_domain>
3392 {
3393 Append_Helper(){}
3394 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3395 #ifdef BOOST_MSVC
3396 ,class Arg6
3397 #endif
3398 >
3399 struct In
3400 {
3401 typedef Append_<Arg1,Arg2,Arg3,Arg4> type;
3402 };
3403 };
3404 Append_Helper const append_;
3405
3406 template <class Container, class Param1, class Param2, class Param3, class Param4 >
3407 struct StringInsert_ : euml_action<StringInsert_<Container,Param1,Param2,Param3,Param4> >
3408 {
3409 template <class Event,class FSM,class STATE >
3410 struct state_action_result
3411 {
3412 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3413 };
3414 template <class EVT,class FSM,class SourceState,class TargetState>
3415 struct transition_action_result
3416 {
3417 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3418 };
3419 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3420
3421 template <class EVT,class FSM,class SourceState,class TargetState>
3422 typename ::boost::enable_if<
3423 typename ::boost::mpl::has_key<
3424 typename Container::tag_type,action_tag>::type,
3425 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3426 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3427 {
3428 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3429 Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
3430 }
3431 template <class Event,class FSM,class STATE>
3432 typename ::boost::enable_if<
3433 typename ::boost::mpl::has_key<
3434 typename Container::tag_type,state_action_tag>::type,
3435 typename state_action_result<Event,FSM,STATE>::type >::type
3436 operator()(Event const& evt,FSM& fsm,STATE& state )const
3437 {
3438 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3439 Param3()(evt,fsm,state),Param4()(evt,fsm,state));
3440 }
3441 };
3442 template <class Container, class Param1, class Param2>
3443 struct StringInsert_ <Container,Param1,Param2,void,void>
3444 : euml_action<StringInsert_<Container,Param1,Param2,void,void> >
3445 {
3446 template <class Event,class FSM,class STATE >
3447 struct state_action_result
3448 {
3449 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3450 };
3451 template <class EVT,class FSM,class SourceState,class TargetState>
3452 struct transition_action_result
3453 {
3454 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3455 };
3456 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3457
3458 template <class EVT,class FSM,class SourceState,class TargetState>
3459 typename ::boost::enable_if<
3460 typename ::boost::mpl::has_key<
3461 typename Container::tag_type,action_tag>::type,
3462 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3463 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3464 {
3465 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3466 }
3467 template <class Event,class FSM,class STATE>
3468 typename ::boost::enable_if<
3469 typename ::boost::mpl::has_key<
3470 typename Container::tag_type,state_action_tag>::type,
3471 typename state_action_result<Event,FSM,STATE>::type >::type
3472 operator()(Event const& evt,FSM& fsm,STATE& state )const
3473 {
3474 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3475 }
3476 };
3477 template <class Container, class Param1, class Param2, class Param3>
3478 struct StringInsert_<Container,Param1,Param2,Param3,void>
3479 : euml_action<StringInsert_<Container,Param1,Param2,Param3,void> >
3480 {
3481 template <class Event,class FSM,class STATE >
3482 struct state_action_result
3483 {
3484 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3485 };
3486 template <class EVT,class FSM,class SourceState,class TargetState>
3487 struct transition_action_result
3488 {
3489 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3490 };
3491 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3492
3493 template <class EVT,class FSM,class SourceState,class TargetState>
3494 typename ::boost::enable_if<
3495 typename ::boost::mpl::has_key<
3496 typename Container::tag_type,action_tag>::type,
3497 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3498 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3499 {
3500 return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3501 Param3()(evt,fsm,src,tgt));
3502 }
3503 template <class Event,class FSM,class STATE>
3504 typename ::boost::enable_if<
3505 typename ::boost::mpl::has_key<
3506 typename Container::tag_type,state_action_tag>::type,
3507 typename state_action_result<Event,FSM,STATE>::type >::type
3508 operator()(Event const& evt,FSM& fsm,STATE& state )const
3509 {
3510 return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3511 Param3()(evt,fsm,state));
3512 }
3513 };
3514
3515 struct string_insert_tag {};
3516 struct StringInsert_Helper: proto::extends< proto::terminal<string_insert_tag>::type, StringInsert_Helper, boost::msm::sm_domain>
3517 {
3518 StringInsert_Helper(){}
3519 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3520 #ifdef BOOST_MSVC
3521 ,class Arg6
3522 #endif
3523 >
3524 struct In
3525 {
3526 typedef StringInsert_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3527 };
3528 };
3529 StringInsert_Helper const string_insert_;
3530
3531 template <class Container,class Param1, class Param2>
3532 struct StringErase_ : euml_action<StringErase_<Container,Param1,Param2> >
3533 {
3534 template <class Event,class FSM,class STATE >
3535 struct state_action_result
3536 {
3537 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3538 };
3539 template <class EVT,class FSM,class SourceState,class TargetState>
3540 struct transition_action_result
3541 {
3542 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3543 };
3544 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3545
3546 template <class EVT,class FSM,class SourceState,class TargetState>
3547 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3548 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3549 {
3550 return (Container()(evt,fsm,src,tgt)).
3551 erase(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3552 }
3553 template <class Event,class FSM,class STATE>
3554 typename state_action_result<Event,FSM,STATE>::type
3555 operator()(Event const& evt,FSM& fsm,STATE& state )const
3556 {
3557 return (Container()(evt,fsm,state)).
3558 erase(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3559 }
3560 };
3561 template <class Container>
3562 struct StringErase_ <Container,void,void>
3563 : euml_action<StringErase_<Container,void,void> >
3564
3565 {
3566 template <class Event,class FSM,class STATE >
3567 struct state_action_result
3568 {
3569 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3570 };
3571 template <class EVT,class FSM,class SourceState,class TargetState>
3572 struct transition_action_result
3573 {
3574 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3575 };
3576 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3577
3578 template <class EVT,class FSM,class SourceState,class TargetState>
3579 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3580 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3581 {
3582 return (Container()(evt,fsm,src,tgt)).erase();
3583 }
3584 template <class Event,class FSM,class STATE>
3585 typename state_action_result<Event,FSM,STATE>::type
3586 operator()(Event const& evt,FSM& fsm,STATE& state )const
3587 {
3588 return (Container()(evt,fsm,state)).erase();
3589 }
3590 };
3591
3592 template <class Container,class Param1>
3593 struct StringErase_ <Container,Param1,void>
3594 : euml_action<StringErase_<Container,Param1,void> >
3595 {
3596 template <class Event,class FSM,class STATE >
3597 struct state_action_result
3598 {
3599 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3600 };
3601 template <class EVT,class FSM,class SourceState,class TargetState>
3602 struct transition_action_result
3603 {
3604 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3605 };
3606 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3607
3608 template <class EVT,class FSM,class SourceState,class TargetState>
3609 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3610 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3611 {
3612 return (Container()(evt,fsm,src,tgt)).erase(Param1()(evt,fsm,src,tgt));
3613 }
3614 template <class Event,class FSM,class STATE>
3615 typename state_action_result<Event,FSM,STATE>::type
3616 operator()(Event const& evt,FSM& fsm,STATE& state )const
3617 {
3618 return (Container()(evt,fsm,state)).erase(Param1()(evt,fsm,state));
3619 }
3620 };
3621
3622 struct string_erase_tag {};
3623 struct StringErase_Helper: proto::extends< proto::terminal<string_erase_tag>::type, StringErase_Helper, boost::msm::sm_domain>
3624 {
3625 StringErase_Helper(){}
3626 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3627 #ifdef BOOST_MSVC
3628 ,class Arg6
3629 #endif
3630 >
3631 struct In
3632 {
3633 typedef StringErase_<Arg1,Arg2,Arg3> type;
3634 };
3635 };
3636 StringErase_Helper const string_erase_;
3637
3638 template <class Container, class Param1, class Param2, class Param3 >
3639 struct StringAssign_ : euml_action<StringAssign_<Container,Param1,Param2,Param3> >
3640 {
3641 template <class Event,class FSM,class STATE >
3642 struct state_action_result
3643 {
3644 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3645 };
3646 template <class EVT,class FSM,class SourceState,class TargetState>
3647 struct transition_action_result
3648 {
3649 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3650 };
3651 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3652
3653 template <class EVT,class FSM,class SourceState,class TargetState>
3654 typename ::boost::enable_if<
3655 typename ::boost::mpl::has_key<
3656 typename Container::tag_type,action_tag>::type,
3657 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3658 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3659 {
3660 return (Container()(evt,fsm,src,tgt)).assign (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3661 Param3()(evt,fsm,src,tgt));
3662 }
3663 template <class Event,class FSM,class STATE>
3664 typename ::boost::enable_if<
3665 typename ::boost::mpl::has_key<
3666 typename Container::tag_type,state_action_tag>::type,
3667 typename state_action_result<Event,FSM,STATE>::type >::type
3668 operator()(Event const& evt,FSM& fsm,STATE& state )const
3669 {
3670 return (Container()(evt,fsm,state)).assign (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3671 Param3()(evt,fsm,state));
3672 }
3673 };
3674 template <class Container,class Param1>
3675 struct StringAssign_ <
3676 Container,Param1,void,void>
3677 : euml_action<StringAssign_<Container,Param1,void,void> >
3678 {
3679 template <class Event,class FSM,class STATE >
3680 struct state_action_result
3681 {
3682 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3683 };
3684 template <class EVT,class FSM,class SourceState,class TargetState>
3685 struct transition_action_result
3686 {
3687 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3688 };
3689 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3690
3691 template <class EVT,class FSM,class SourceState,class TargetState>
3692 typename ::boost::enable_if<
3693 typename ::boost::mpl::has_key<
3694 typename Container::tag_type,action_tag>::type,
3695 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3696 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3697 {
3698 return (Container()(evt,fsm,src,tgt)).assign(Param1()(evt,fsm,src,tgt));
3699 }
3700 template <class Event,class FSM,class STATE>
3701 typename ::boost::enable_if<
3702 typename ::boost::mpl::has_key<
3703 typename Container::tag_type,state_action_tag>::type,
3704 typename state_action_result<Event,FSM,STATE>::type >::type
3705 operator()(Event const& evt,FSM& fsm,STATE& state )const
3706 {
3707 return (Container()(evt,fsm,state)).assign(Param1()(evt,fsm,state));
3708 }
3709 };
3710
3711 template <class Container, class Param1, class Param2 >
3712 struct StringAssign_<Container,Param1,Param2,void>
3713 : euml_action<StringAssign_<Container,Param1,Param2,void> >
3714 {
3715 template <class Event,class FSM,class STATE >
3716 struct state_action_result
3717 {
3718 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3719 };
3720 template <class EVT,class FSM,class SourceState,class TargetState>
3721 struct transition_action_result
3722 {
3723 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3724 };
3725 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3726
3727 template <class EVT,class FSM,class SourceState,class TargetState>
3728 typename ::boost::enable_if<
3729 typename ::boost::mpl::has_key<
3730 typename Container::tag_type,action_tag>::type,
3731 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3732 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3733 {
3734 return (Container()(evt,fsm,src,tgt)).assign(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
3735 }
3736 template <class Event,class FSM,class STATE>
3737 typename ::boost::enable_if<
3738 typename ::boost::mpl::has_key<
3739 typename Container::tag_type,state_action_tag>::type,
3740 typename state_action_result<Event,FSM,STATE>::type >::type
3741 operator()(Event const& evt,FSM& fsm,STATE& state )const
3742 {
3743 return (Container()(evt,fsm,state)).assign(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
3744 }
3745 };
3746 struct assign_tag {};
3747 struct StringAssign_Helper: proto::extends< proto::terminal<assign_tag>::type, StringAssign_Helper, boost::msm::sm_domain>
3748 {
3749 StringAssign_Helper(){}
3750 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3751 #ifdef BOOST_MSVC
3752 ,class Arg6
3753 #endif
3754 >
3755 struct In
3756 {
3757 typedef StringAssign_<Arg1,Arg2,Arg3,Arg4> type;
3758 };
3759 };
3760 StringAssign_Helper const string_assign_;
3761
3762 template <class Container,class Param1, class Param2, class Param3, class Param4>
3763 struct StringReplace_ : euml_action<StringReplace_<Container,Param1,Param2,Param3,Param4> >
3764 {
3765 template <class Event,class FSM,class STATE >
3766 struct state_action_result
3767 {
3768 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3769 };
3770 template <class EVT,class FSM,class SourceState,class TargetState>
3771 struct transition_action_result
3772 {
3773 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3774 };
3775 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3776
3777 template <class EVT,class FSM,class SourceState,class TargetState>
3778 typename ::boost::enable_if<
3779 typename ::boost::mpl::has_key<
3780 typename Container::tag_type,action_tag>::type,
3781 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3782 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3783 {
3784 return (Container()(evt,fsm,src,tgt)).replace (Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3785 Param3()(evt,fsm,src,tgt),Param4()(evt,fsm,src,tgt));
3786 }
3787 template <class Event,class FSM,class STATE>
3788 typename ::boost::enable_if<
3789 typename ::boost::mpl::has_key<
3790 typename Container::tag_type,state_action_tag>::type,
3791 typename state_action_result<Event,FSM,STATE>::type >::type
3792 operator()(Event const& evt,FSM& fsm,STATE& state )const
3793 {
3794 return (Container()(evt,fsm,state)).replace (Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3795 Param3()(evt,fsm,state),Param4()(evt,fsm,state));
3796 }
3797 };
3798
3799 template <class Container,class Param1, class Param2, class Param3>
3800 struct StringReplace_<Container,Param1,Param2,Param3,void>
3801 : euml_action<StringReplace_<Container,Param1,Param2,Param3,void> >
3802 {
3803 template <class Event,class FSM,class STATE >
3804 struct state_action_result
3805 {
3806 typedef typename get_result_type2<Container,Event,FSM,STATE>::type type;
3807 };
3808 template <class EVT,class FSM,class SourceState,class TargetState>
3809 struct transition_action_result
3810 {
3811 typedef typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type type;
3812 };
3813 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3814
3815 template <class EVT,class FSM,class SourceState,class TargetState>
3816 typename ::boost::enable_if<
3817 typename ::boost::mpl::has_key<
3818 typename Container::tag_type,action_tag>::type,
3819 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3820 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3821 {
3822 return (Container()(evt,fsm,src,tgt)).replace(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
3823 Param3()(evt,fsm,src,tgt));
3824 }
3825 template <class Event,class FSM,class STATE>
3826 typename ::boost::enable_if<
3827 typename ::boost::mpl::has_key<
3828 typename Container::tag_type,state_action_tag>::type,
3829 typename state_action_result<Event,FSM,STATE>::type >::type
3830 operator()(Event const& evt,FSM& fsm,STATE& state )const
3831 {
3832 return (Container()(evt,fsm,state)).replace(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
3833 Param3()(evt,fsm,state));
3834 }
3835 };
3836
3837 struct string_replace_tag {};
3838 struct StringReplace_Helper: proto::extends< proto::terminal<string_replace_tag>::type, StringReplace_Helper, boost::msm::sm_domain>
3839 {
3840 StringReplace_Helper(){}
3841 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3842 #ifdef BOOST_MSVC
3843 ,class Arg6
3844 #endif
3845 >
3846 struct In
3847 {
3848 typedef StringReplace_<Arg1,Arg2,Arg3,Arg4,Arg5> type;
3849 };
3850 };
3851 StringReplace_Helper const string_replace_;
3852
3853 template <class Container>
3854 struct CStr_ : euml_action<CStr_<Container> >
3855 {
3856 template <class Event,class FSM,class STATE >
3857 struct state_action_result
3858 {
3859 typedef typename ::boost::add_const<
3860 typename get_value_type<
3861 typename ::boost::remove_reference<
3862 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type>::type* type;
3863 };
3864 template <class EVT,class FSM,class SourceState,class TargetState>
3865 struct transition_action_result
3866 {
3867 typedef typename ::boost::add_const<
3868 typename get_value_type<
3869 typename ::boost::remove_reference<
3870 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type>::type* type;
3871 };
3872 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3873
3874 template <class EVT,class FSM,class SourceState,class TargetState>
3875 typename ::boost::enable_if<
3876 typename ::boost::mpl::has_key<
3877 typename Container::tag_type,action_tag>::type,
3878 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3879 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3880 {
3881 return (Container()(evt,fsm,src,tgt)).c_str();
3882 }
3883 template <class Event,class FSM,class STATE>
3884 typename ::boost::enable_if<
3885 typename ::boost::mpl::has_key<
3886 typename Container::tag_type,state_action_tag>::type,
3887 typename state_action_result<Event,FSM,STATE>::type >::type
3888 operator()(Event const& evt,FSM& fsm,STATE& state )const
3889 {
3890 return (Container()(evt,fsm,state)).c_str();
3891 }
3892 };
3893 struct c_str_tag {};
3894 struct CStr_Helper: proto::extends< proto::terminal<c_str_tag>::type, CStr_Helper, boost::msm::sm_domain>
3895 {
3896 CStr_Helper(){}
3897 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3898 #ifdef BOOST_MSVC
3899 ,class Arg6
3900 #endif
3901 >
3902 struct In
3903 {
3904 typedef CStr_<Arg1> type;
3905 };
3906 };
3907 CStr_Helper const c_str_;
3908
3909 template <class Container>
3910 struct StringData_ : euml_action<StringData_<Container> >
3911 {
3912 template <class Event,class FSM,class STATE >
3913 struct state_action_result
3914 {
3915 typedef typename ::boost::add_const<
3916 typename get_value_type<
3917 typename ::boost::remove_reference<
3918 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type>::type* type;
3919 };
3920 template <class EVT,class FSM,class SourceState,class TargetState>
3921 struct transition_action_result
3922 {
3923 typedef typename ::boost::add_const<
3924 typename get_value_type<
3925 typename ::boost::remove_reference<
3926 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type>::type* type;
3927 };
3928 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3929
3930 template <class EVT,class FSM,class SourceState,class TargetState>
3931 typename ::boost::enable_if<
3932 typename ::boost::mpl::has_key<
3933 typename Container::tag_type,action_tag>::type,
3934 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type
3935 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3936 {
3937 return (Container()(evt,fsm,src,tgt)).data();
3938 }
3939 template <class Event,class FSM,class STATE>
3940 typename ::boost::enable_if<
3941 typename ::boost::mpl::has_key<
3942 typename Container::tag_type,state_action_tag>::type,
3943 typename state_action_result<Event,FSM,STATE>::type >::type
3944 operator()(Event const& evt,FSM& fsm,STATE& state )const
3945 {
3946 return (Container()(evt,fsm,state)).data();
3947 }
3948 };
3949 struct string_data_tag {};
3950 struct StringData_Helper: proto::extends< proto::terminal<string_data_tag>::type, StringData_Helper, boost::msm::sm_domain>
3951 {
3952 StringData_Helper(){}
3953 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
3954 #ifdef BOOST_MSVC
3955 ,class Arg6
3956 #endif
3957 >
3958 struct In
3959 {
3960 typedef StringData_<Arg1> type;
3961 };
3962 };
3963 StringData_Helper const string_data_;
3964
3965 template <class Container, class Param1, class Param2, class Param3, class Enable=void >
3966 struct StringCopy_ : euml_action<StringCopy_<Container,Param1,Param2,Param3,Enable> >
3967 {
3968 };
3969
3970 template <class Container,class Param1, class Param2, class Param3>
3971 struct StringCopy_<
3972 Container,Param1,Param2,Param3,
3973 typename ::boost::enable_if<
3974 typename ::boost::is_same<Param3,void>::type
3975 >::type
3976 >
3977 : euml_action<StringCopy_<Container,Param1,Param2,Param3> >
3978 {
3979 template <class Event,class FSM,class STATE >
3980 struct state_action_result
3981 {
3982 typedef typename get_size_type<
3983 typename ::boost::remove_reference<
3984 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
3985 };
3986 template <class EVT,class FSM,class SourceState,class TargetState>
3987 struct transition_action_result
3988 {
3989 typedef typename get_size_type<
3990 typename ::boost::remove_reference<
3991 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
3992 };
3993 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
3994
3995 template <class EVT,class FSM,class SourceState,class TargetState>
3996 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
3997 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
3998 {
3999 return (Container()(evt,fsm,src,tgt)).copy(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
4000 }
4001 template <class Event,class FSM,class STATE>
4002 typename state_action_result<Event,FSM,STATE>::type
4003 operator()(Event const& evt,FSM& fsm,STATE& state )const
4004 {
4005 return (Container()(evt,fsm,state)).copy(Param1()(evt,fsm,state),Param2()(evt,fsm,state));
4006 }
4007 };
4008
4009 template <class Container,class Param1, class Param2, class Param3>
4010 struct StringCopy_<
4011 Container,Param1,Param2,Param3,
4012 typename ::boost::disable_if<
4013 typename ::boost::is_same<Param3,void>::type
4014 >::type
4015 >
4016 : euml_action<StringCopy_<Container,Param1,Param2,Param3> >
4017 {
4018 template <class Event,class FSM,class STATE >
4019 struct state_action_result
4020 {
4021 typedef typename get_size_type<
4022 typename ::boost::remove_reference<
4023 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
4024 };
4025 template <class EVT,class FSM,class SourceState,class TargetState>
4026 struct transition_action_result
4027 {
4028 typedef typename get_size_type<
4029 typename ::boost::remove_reference<
4030 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
4031 };
4032 typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
4033
4034 template <class EVT,class FSM,class SourceState,class TargetState>
4035 typename transition_action_result<EVT,FSM,SourceState,TargetState>::type
4036 operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
4037 {
4038 return (Container()(evt,fsm,src,tgt)).
4039 copy(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),Param3()(evt,fsm,src,tgt));
4040 }
4041 template <class Event,class FSM,class STATE>
4042 typename state_action_result<Event,FSM,STATE>::type
4043 operator()(Event const& evt,FSM& fsm,STATE& state )const
4044 {
4045 return (Container()(evt,fsm,state)).
4046 copy(Param1()(evt,fsm,state),Param2()(evt,fsm,state),Param3()(evt,fsm,state));
4047 }
4048 };
4049
4050 struct string_copy_tag {};
4051 struct StringCopy_Helper: proto::extends< proto::terminal<string_copy_tag>::type, StringCopy_Helper, boost::msm::sm_domain>
4052 {
4053 StringCopy_Helper(){}
4054 template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5
4055 #ifdef BOOST_MSVC
4056 ,class Arg6
4057 #endif
4058 >
4059 struct In
4060 {
4061 typedef StringCopy_<Arg1,Arg2,Arg3,Arg4> type;
4062 };
4063 };
4064 StringCopy_Helper const string_copy_;
4065
4066 }}}}
4067
4068 #endif //BOOST_MSM_FRONT_EUML_CONTAINER_H