/Src/Dependencies/Boost/boost/msm/front/euml/container.hpp

http://hadesmem.googlecode.com/ · C++ Header · 4068 lines · 3829 code · 209 blank · 30 comment · 0 complexity · 928ae93525be5a40a884f3c64c405476 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. // Copyright 2008 Christophe Henry
    2. 

  2. // henry UNDERSCORE christophe AT hotmail DOT com
    3. 

  3. // This is an extended version of the state machine available in the boost::mpl library
    4. 

  4. // Distributed under the same license as the original.
    5. 

  5. // Copyright for the original version:
    6. 

  6. // Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
    7. 

  7. // under the Boost Software License, Version 1.0. (See accompanying
    8. 

  8. // file LICENSE_1_0.txt or copy at
    9. 

  9. // http://www.boost.org/LICENSE_1_0.txt)
    10. 

  10. 

  11. #ifndef BOOST_MSM_FRONT_EUML_CONTAINER_H
    12. 

  12. #define BOOST_MSM_FRONT_EUML_CONTAINER_H
    13. 

  13. 

  14. #include <utility>
    15. 

  15. #include <boost/msm/front/euml/common.hpp>
    16. 

  16. #include <boost/utility/enable_if.hpp>
    17. 

  17. #include <boost/mpl/has_key.hpp>
    18. 

  18. #include <boost/mpl/set.hpp>
    19. 

  19. #include <boost/mpl/not.hpp>
    20. 

  20. #include <boost/msm/front/euml/operator.hpp>
    21. 

  21. #include <boost/type_traits.hpp>
    22. 

  22. 

  23. BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
    24. 

  24. 

  25. namespace boost { namespace msm { namespace front { namespace euml
    26. 

  26. {
    27. 

  27. 

  28. template <class T>
    29. 

  29. struct Front_ : euml_action<Front_<T> >
    30. 

  30. {
    31. 

  31.     template <class Event,class FSM,class STATE >
    32. 

  32.     struct state_action_result 
    33. 

  33.     {
    34. 

  34.         typedef typename get_reference< 
    35. 

  35.             typename ::boost::remove_reference<
    36. 

  36.                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
    37. 

  37.     };
    38. 

  38.     template <class EVT,class FSM,class SourceState,class TargetState>
    39. 

  39.     struct transition_action_result 
    40. 

  40.     {
    41. 

  41.         typedef typename get_reference< 
    42. 

  42.             typename ::boost::remove_reference<
    43. 

  43.                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    44. 

  44.     };
    45. 

  45.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    46. 

  46. 

  47.     template <class EVT,class FSM,class SourceState,class TargetState>
    48. 

  48.     typename ::boost::enable_if<
    49. 

  49.         typename ::boost::mpl::has_key<
    50. 

  50.             typename T::tag_type,action_tag>::type,
    51. 

  51.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    52. 

  52.         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    53. 

  53.     {
    54. 

  54.         return (T()(evt,fsm,src,tgt)).front();
    55. 

  55.     }
    56. 

  56.     template <class Event,class FSM,class STATE>
    57. 

  57.     typename ::boost::enable_if<
    58. 

  58.         typename ::boost::mpl::has_key<
    59. 

  59.             typename T::tag_type,state_action_tag>::type,
    60. 

  60.             typename state_action_result<Event,FSM,STATE>::type >::type 
    61. 

  61.         operator()(Event const& evt,FSM& fsm,STATE& state )const
    62. 

  62.     {
    63. 

  63.         return (T()(evt,fsm,state)).front();
    64. 

  64.     }
    65. 

  65. };
    66. 

  66. 

  67. struct front_tag {};
    68. 

  68. struct Front_Helper: proto::extends< proto::terminal<front_tag>::type, Front_Helper, sm_domain>
    69. 

  69. {
    70. 

  70.     Front_Helper(){}
    71. 

  71.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    72. 

  72. #ifdef BOOST_MSVC 
    73. 

  73.  ,class Arg6 
    74. 

  74. #endif
    75. 

  75. >
    76. 

  76.     struct In
    77. 

  77.     {
    78. 

  78.         typedef Front_<Arg1> type;
    79. 

  79.     };
    80. 

  80. };
    81. 

  81. Front_Helper const front_;
    82. 

  82. 

  83. template <class T>
    84. 

  84. struct Back_ : euml_action<Back_<T> >
    85. 

  85. {
    86. 

  86.     template <class Event,class FSM,class STATE >
    87. 

  87.     struct state_action_result 
    88. 

  88.     {
    89. 

  89.         typedef typename get_reference< 
    90. 

  90.             typename ::boost::remove_reference<
    91. 

  91.                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
    92. 

  92.     };
    93. 

  93.     template <class EVT,class FSM,class SourceState,class TargetState>
    94. 

  94.     struct transition_action_result 
    95. 

  95.     {
    96. 

  96.         typedef typename get_reference< 
    97. 

  97.             typename ::boost::remove_reference<
    98. 

  98.                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    99. 

  99.     };
    100. 

  100.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    101. 

  101. 

  102.     template <class EVT,class FSM,class SourceState,class TargetState>
    103. 

  103.     typename ::boost::enable_if<
    104. 

  104.         typename ::boost::mpl::has_key<
    105. 

  105.             typename T::tag_type,action_tag>::type,
    106. 

  106.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    107. 

  107.         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    108. 

  108.     {
    109. 

  109.         return (T()(evt,fsm,src,tgt)).back();
    110. 

  110.     }
    111. 

  111.     template <class Event,class FSM,class STATE>
    112. 

  112.     typename ::boost::enable_if<
    113. 

  113.         typename ::boost::mpl::has_key<
    114. 

  114.             typename T::tag_type,state_action_tag>::type,
    115. 

  115.             typename state_action_result<Event,FSM,STATE>::type >::type 
    116. 

  116.         operator()(Event const& evt,FSM& fsm,STATE& state )const
    117. 

  117.     {
    118. 

  118.         return (T()(evt,fsm,state)).back();
    119. 

  119.     }
    120. 

  120. };
    121. 

  121. 

  122. struct back_tag {};
    123. 

  123. struct Back_Helper: proto::extends< proto::terminal<back_tag>::type, Back_Helper, sm_domain>
    124. 

  124. {
    125. 

  125.     Back_Helper(){}
    126. 

  126.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    127. 

  127. #ifdef BOOST_MSVC 
    128. 

  128.  ,class Arg6 
    129. 

  129. #endif
    130. 

  130. >
    131. 

  131.     struct In
    132. 

  132.     {
    133. 

  133.         typedef Back_<Arg1> type;
    134. 

  134.     };
    135. 

  135. };
    136. 

  136. Back_Helper const back_;
    137. 

  137. 

  138. template <class T>
    139. 

  139. struct Begin_ : euml_action<Begin_<T> >
    140. 

  140. {
    141. 

  141.     template <class Event,class FSM,class STATE >
    142. 

  142.     struct state_action_result 
    143. 

  143.     {
    144. 

  144.         typedef typename get_iterator< 
    145. 

  145.             typename ::boost::remove_reference<
    146. 

  146.                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
    147. 

  147.     };
    148. 

  148.     template <class EVT,class FSM,class SourceState,class TargetState>
    149. 

  149.     struct transition_action_result 
    150. 

  150.     {
    151. 

  151.         typedef typename get_iterator< 
    152. 

  152.             typename ::boost::remove_reference<
    153. 

  153.                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    154. 

  154.     };
    155. 

  155.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    156. 

  156. 

  157.     template <class EVT,class FSM,class SourceState,class TargetState>
    158. 

  158.     typename ::boost::enable_if<
    159. 

  159.         typename ::boost::mpl::has_key<
    160. 

  160.             typename T::tag_type,action_tag>::type,
    161. 

  161.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    162. 

  162.         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    163. 

  163.     {
    164. 

  164.         return (T()(evt,fsm,src,tgt)).begin();
    165. 

  165.     }
    166. 

  166.     template <class Event,class FSM,class STATE>
    167. 

  167.     typename ::boost::enable_if<
    168. 

  168.         typename ::boost::mpl::has_key<
    169. 

  169.             typename T::tag_type,state_action_tag>::type,
    170. 

  170.             typename state_action_result<Event,FSM,STATE>::type >::type 
    171. 

  171.         operator()(Event const& evt,FSM& fsm,STATE& state )const
    172. 

  172.     {
    173. 

  173.         return (T()(evt,fsm,state)).begin();
    174. 

  174.     }
    175. 

  175. };
    176. 

  176. 

  177. struct begin_tag {};
    178. 

  178. struct Begin_Helper: proto::extends< proto::terminal<begin_tag>::type, Begin_Helper, sm_domain>
    179. 

  179. {
    180. 

  180.     Begin_Helper(){}
    181. 

  181.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    182. 

  182. #ifdef BOOST_MSVC 
    183. 

  183.  ,class Arg6 
    184. 

  184. #endif
    185. 

  185. >
    186. 

  186.     struct In
    187. 

  187.     {
    188. 

  188.         typedef Begin_<Arg1> type;
    189. 

  189.     };
    190. 

  190. };
    191. 

  191. Begin_Helper const begin_;
    192. 

  192. 

  193. template <class T>
    194. 

  194. struct End_ : euml_action<End_<T> >
    195. 

  195. {
    196. 

  196.     template <class Event,class FSM,class STATE >
    197. 

  197.     struct state_action_result 
    198. 

  198.     {
    199. 

  199.         typedef typename get_iterator< 
    200. 

  200.             typename ::boost::remove_reference<
    201. 

  201.                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
    202. 

  202.     };
    203. 

  203.     template <class EVT,class FSM,class SourceState,class TargetState>
    204. 

  204.     struct transition_action_result 
    205. 

  205.     {
    206. 

  206.         typedef typename get_iterator< 
    207. 

  207.             typename ::boost::remove_reference<
    208. 

  208.                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    209. 

  209.     };
    210. 

  210.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    211. 

  211. 

  212.     template <class EVT,class FSM,class SourceState,class TargetState>
    213. 

  213.     typename ::boost::enable_if<
    214. 

  214.         typename ::boost::mpl::has_key<
    215. 

  215.             typename T::tag_type,action_tag>::type,
    216. 

  216.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    217. 

  217.         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    218. 

  218.     {
    219. 

  219.         return (T()(evt,fsm,src,tgt)).end();
    220. 

  220.     }
    221. 

  221.     template <class Event,class FSM,class STATE>
    222. 

  222.     typename ::boost::enable_if<
    223. 

  223.         typename ::boost::mpl::has_key<
    224. 

  224.             typename T::tag_type,state_action_tag>::type,
    225. 

  225.             typename state_action_result<Event,FSM,STATE>::type >::type 
    226. 

  226.         operator()(Event const& evt,FSM& fsm,STATE& state )const
    227. 

  227.     {
    228. 

  228.         return (T()(evt,fsm,state)).end();
    229. 

  229.     }
    230. 

  230. };
    231. 

  231. struct end_tag {};
    232. 

  232. struct End_Helper: proto::extends< proto::terminal<end_tag>::type, End_Helper, sm_domain>
    233. 

  233. {
    234. 

  234.     End_Helper(){}
    235. 

  235.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    236. 

  236. #ifdef BOOST_MSVC 
    237. 

  237.  ,class Arg6 
    238. 

  238. #endif
    239. 

  239. >
    240. 

  240.     struct In
    241. 

  241.     {
    242. 

  242.         typedef End_<Arg1> type;
    243. 

  243.     };
    244. 

  244. };
    245. 

  245. End_Helper const end_;
    246. 

  246. 

  247. template <class T>
    248. 

  248. struct RBegin_ : euml_action<RBegin_<T> >
    249. 

  249. {
    250. 

  250.     template <class Event,class FSM,class STATE >
    251. 

  251.     struct state_action_result 
    252. 

  252.     {
    253. 

  253.         typedef typename get_reverse_iterator< 
    254. 

  254.             typename ::boost::remove_reference<
    255. 

  255.                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
    256. 

  256.     };
    257. 

  257.     template <class EVT,class FSM,class SourceState,class TargetState>
    258. 

  258.     struct transition_action_result 
    259. 

  259.     {
    260. 

  260.         typedef typename get_reverse_iterator< 
    261. 

  261.             typename ::boost::remove_reference<
    262. 

  262.                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    263. 

  263.     };
    264. 

  264.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    265. 

  265. 

  266.     template <class EVT,class FSM,class SourceState,class TargetState>
    267. 

  267.     typename ::boost::enable_if<
    268. 

  268.         typename ::boost::mpl::has_key<
    269. 

  269.             typename T::tag_type,action_tag>::type,
    270. 

  270.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    271. 

  271.         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    272. 

  272.     {
    273. 

  273.         return (T()(evt,fsm,src,tgt)).rbegin();
    274. 

  274.     }
    275. 

  275.     template <class Event,class FSM,class STATE>
    276. 

  276.     typename ::boost::enable_if<
    277. 

  277.         typename ::boost::mpl::has_key<
    278. 

  278.             typename T::tag_type,state_action_tag>::type,
    279. 

  279.             typename state_action_result<Event,FSM,STATE>::type >::type 
    280. 

  280.         operator()(Event const& evt,FSM& fsm,STATE& state )const
    281. 

  281.     {
    282. 

  282.         return (T()(evt,fsm,state)).rbegin();
    283. 

  283.     }
    284. 

  284. };
    285. 

  285. 

  286. struct rbegin_tag {};
    287. 

  287. struct RBegin_Helper: proto::extends< proto::terminal<rbegin_tag>::type, RBegin_Helper, sm_domain>
    288. 

  288. {
    289. 

  289.     RBegin_Helper(){}
    290. 

  290.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    291. 

  291. #ifdef BOOST_MSVC 
    292. 

  292.  ,class Arg6 
    293. 

  293. #endif
    294. 

  294. >
    295. 

  295.     struct In
    296. 

  296.     {
    297. 

  297.         typedef RBegin_<Arg1> type;
    298. 

  298.     };
    299. 

  299. };
    300. 

  300. RBegin_Helper const rbegin_;
    301. 

  301. 

  302. template <class T>
    303. 

  303. struct REnd_ : euml_action<REnd_<T> >
    304. 

  304. {
    305. 

  305.     template <class Event,class FSM,class STATE >
    306. 

  306.     struct state_action_result 
    307. 

  307.     {
    308. 

  308.         typedef typename get_reverse_iterator< 
    309. 

  309.             typename ::boost::remove_reference<
    310. 

  310.                 typename get_result_type2<T,Event,FSM,STATE>::type>::type>::type type;
    311. 

  311.     };
    312. 

  312.     template <class EVT,class FSM,class SourceState,class TargetState>
    313. 

  313.     struct transition_action_result 
    314. 

  314.     {
    315. 

  315.         typedef typename get_reverse_iterator< 
    316. 

  316.             typename ::boost::remove_reference<
    317. 

  317.                 typename get_result_type<T,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    318. 

  318.     };
    319. 

  319.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    320. 

  320. 

  321.     template <class EVT,class FSM,class SourceState,class TargetState>
    322. 

  322.     typename ::boost::enable_if<
    323. 

  323.         typename ::boost::mpl::has_key<
    324. 

  324.             typename T::tag_type,action_tag>::type,
    325. 

  325.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    326. 

  326.         operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    327. 

  327.     {
    328. 

  328.         return (T()(evt,fsm,src,tgt)).rend();
    329. 

  329.     }
    330. 

  330.     template <class Event,class FSM,class STATE>
    331. 

  331.     typename ::boost::enable_if<
    332. 

  332.         typename ::boost::mpl::has_key<
    333. 

  333.             typename T::tag_type,state_action_tag>::type,
    334. 

  334.             typename state_action_result<Event,FSM,STATE>::type >::type 
    335. 

  335.         operator()(Event const& evt,FSM& fsm,STATE& state )const
    336. 

  336.     {
    337. 

  337.         return (T()(evt,fsm,state)).rend();
    338. 

  338.     }
    339. 

  339. };
    340. 

  340. struct rend_tag {};
    341. 

  341. struct REnd_Helper: proto::extends< proto::terminal<rend_tag>::type, REnd_Helper, sm_domain>
    342. 

  342. {
    343. 

  343.     REnd_Helper(){}
    344. 

  344.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    345. 

  345. #ifdef BOOST_MSVC 
    346. 

  346.  ,class Arg6 
    347. 

  347. #endif
    348. 

  348. >
    349. 

  349.     struct In
    350. 

  350.     {
    351. 

  351.         typedef REnd_<Arg1> type;
    352. 

  352.     };
    353. 

  353. };
    354. 

  354. REnd_Helper const rend_;
    355. 

  355. 

  356. template <class Container,class Element>
    357. 

  357. struct Push_Back_ : euml_action<Push_Back_<Container,Element> >
    358. 

  358. {
    359. 

  359.     template <class Event,class FSM,class STATE >
    360. 

  360.     struct state_action_result 
    361. 

  361.     {
    362. 

  362.         typedef void type;
    363. 

  363.     };
    364. 

  364.     template <class EVT,class FSM,class SourceState,class TargetState>
    365. 

  365.     struct transition_action_result 
    366. 

  366.     {
    367. 

  367.         typedef void type;
    368. 

  368.     };
    369. 

  369.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    370. 

  370. 

  371.     template <class EVT,class FSM,class SourceState,class TargetState> 
    372. 

  372.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    373. 

  373.     {
    374. 

  374.         (Container()(evt,fsm,src,tgt)).push_back(Element()(evt,fsm,src,tgt));
    375. 

  375.     }
    376. 

  376.     template <class Event,class FSM,class STATE>
    377. 

  377.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    378. 

  378.     {
    379. 

  379.         (Container()(evt,fsm,state)).push_back(Element()(evt,fsm,state));        
    380. 

  380.     }
    381. 

  381. };
    382. 

  382. struct push_back_tag {};
    383. 

  383. struct Push_Back_Helper: proto::extends< proto::terminal<push_back_tag>::type, Push_Back_Helper, sm_domain>
    384. 

  384. {
    385. 

  385.     Push_Back_Helper(){}
    386. 

  386.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    387. 

  387. #ifdef BOOST_MSVC 
    388. 

  388.  ,class Arg6 
    389. 

  389. #endif
    390. 

  390. >
    391. 

  391.     struct In
    392. 

  392.     {
    393. 

  393.         typedef Push_Back_<Arg1,Arg2> type;
    394. 

  394.     };
    395. 

  395. };
    396. 

  396. Push_Back_Helper const push_back_;
    397. 

  397. 

  398. template <class Container>
    399. 

  399. struct Pop_Back_ : euml_action<Pop_Back_<Container> >
    400. 

  400. {
    401. 

  401.     template <class Event,class FSM,class STATE >
    402. 

  402.     struct state_action_result 
    403. 

  403.     {
    404. 

  404.         typedef void type;
    405. 

  405.     };
    406. 

  406.     template <class EVT,class FSM,class SourceState,class TargetState>
    407. 

  407.     struct transition_action_result 
    408. 

  408.     {
    409. 

  409.         typedef void type;
    410. 

  410.     };
    411. 

  411.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    412. 

  412. 

  413.     template <class EVT,class FSM,class SourceState,class TargetState> 
    414. 

  414.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    415. 

  415.     {
    416. 

  416.         (Container()(evt,fsm,src,tgt)).pop_back();
    417. 

  417.     }
    418. 

  418.     template <class Event,class FSM,class STATE>
    419. 

  419.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    420. 

  420.     {
    421. 

  421.         (Container()(evt,fsm,state)).pop_back();        
    422. 

  422.     }
    423. 

  423. };
    424. 

  424. struct pop_back_tag {};
    425. 

  425. struct Pop_Back_Helper: proto::extends< proto::terminal<pop_back_tag>::type, Pop_Back_Helper, sm_domain>
    426. 

  426. {
    427. 

  427.     Pop_Back_Helper(){}
    428. 

  428.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    429. 

  429. #ifdef BOOST_MSVC 
    430. 

  430.  ,class Arg6 
    431. 

  431. #endif
    432. 

  432. >
    433. 

  433.     struct In
    434. 

  434.     {
    435. 

  435.         typedef Pop_Back_<Arg1> type;
    436. 

  436.     };
    437. 

  437. };
    438. 

  438. Pop_Back_Helper const pop_back_;
    439. 

  439. 

  440. template <class Container,class Element>
    441. 

  441. struct Push_Front_ : euml_action<Push_Front_<Container,Element> >
    442. 

  442. {
    443. 

  443.     template <class Event,class FSM,class STATE >
    444. 

  444.     struct state_action_result 
    445. 

  445.     {
    446. 

  446.         typedef void type;
    447. 

  447.     };
    448. 

  448.     template <class EVT,class FSM,class SourceState,class TargetState>
    449. 

  449.     struct transition_action_result 
    450. 

  450.     {
    451. 

  451.         typedef void type;
    452. 

  452.     };
    453. 

  453.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    454. 

  454. 

  455.     template <class EVT,class FSM,class SourceState,class TargetState> 
    456. 

  456.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    457. 

  457.     {
    458. 

  458.         (Container()(evt,fsm,src,tgt)).push_front(Element()(evt,fsm,src,tgt));
    459. 

  459.     }
    460. 

  460.     template <class Event,class FSM,class STATE>
    461. 

  461.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    462. 

  462.     {
    463. 

  463.         (Container()(evt,fsm,state)).push_front(Element()(evt,fsm,state));        
    464. 

  464.     }
    465. 

  465. };
    466. 

  466. struct push_front_tag {};
    467. 

  467. struct Push_Front_Helper: proto::extends< proto::terminal<push_front_tag>::type, Push_Front_Helper, sm_domain>
    468. 

  468. {
    469. 

  469.     Push_Front_Helper(){}
    470. 

  470.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    471. 

  471. #ifdef BOOST_MSVC 
    472. 

  472.  ,class Arg6 
    473. 

  473. #endif
    474. 

  474. >
    475. 

  475.     struct In
    476. 

  476.     {
    477. 

  477.         typedef Push_Front_<Arg1,Arg2> type;
    478. 

  478.     };
    479. 

  479. };
    480. 

  480. Push_Front_Helper const push_front_;
    481. 

  481. 

  482. template <class Container>
    483. 

  483. struct Pop_Front_ : euml_action<Pop_Front_<Container> >
    484. 

  484. {
    485. 

  485.     template <class Event,class FSM,class STATE >
    486. 

  486.     struct state_action_result 
    487. 

  487.     {
    488. 

  488.         typedef void type;
    489. 

  489.     };
    490. 

  490.     template <class EVT,class FSM,class SourceState,class TargetState>
    491. 

  491.     struct transition_action_result 
    492. 

  492.     {
    493. 

  493.         typedef void type;
    494. 

  494.     };
    495. 

  495.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    496. 

  496. 

  497.     template <class EVT,class FSM,class SourceState,class TargetState> 
    498. 

  498.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    499. 

  499.     {
    500. 

  500.         (Container()(evt,fsm,src,tgt)).pop_front();
    501. 

  501.     }
    502. 

  502.     template <class Event,class FSM,class STATE>
    503. 

  503.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    504. 

  504.     {
    505. 

  505.         (Container()(evt,fsm,state)).pop_front();        
    506. 

  506.     }
    507. 

  507. };
    508. 

  508. struct pop_front_tag {};
    509. 

  509. struct Pop_Front_Helper: proto::extends< proto::terminal<pop_front_tag>::type, Pop_Front_Helper, sm_domain>
    510. 

  510. {
    511. 

  511.     Pop_Front_Helper(){}
    512. 

  512.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    513. 

  513. #ifdef BOOST_MSVC 
    514. 

  514.  ,class Arg6 
    515. 

  515. #endif
    516. 

  516. >
    517. 

  517.     struct In
    518. 

  518.     {
    519. 

  519.         typedef Pop_Front_<Arg1> type;
    520. 

  520.     };
    521. 

  521. };
    522. 

  522. Pop_Front_Helper const pop_front_;
    523. 

  523. 

  524. template <class Container>
    525. 

  525. struct Clear_ : euml_action<Clear_<Container> >
    526. 

  526. {
    527. 

  527.     template <class Event,class FSM,class STATE >
    528. 

  528.     struct state_action_result 
    529. 

  529.     {
    530. 

  530.         typedef void type;
    531. 

  531.     };
    532. 

  532.     template <class EVT,class FSM,class SourceState,class TargetState>
    533. 

  533.     struct transition_action_result 
    534. 

  534.     {
    535. 

  535.         typedef void type;
    536. 

  536.     };
    537. 

  537.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    538. 

  538. 

  539.     template <class EVT,class FSM,class SourceState,class TargetState> 
    540. 

  540.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    541. 

  541.     {
    542. 

  542.         (Container()(evt,fsm,src,tgt)).clear();
    543. 

  543.     }
    544. 

  544.     template <class Event,class FSM,class STATE>
    545. 

  545.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    546. 

  546.     {
    547. 

  547.         (Container()(evt,fsm,state)).clear();        
    548. 

  548.     }
    549. 

  549. };
    550. 

  550. struct clear_tag {};
    551. 

  551. struct Clear_Helper: proto::extends< proto::terminal<clear_tag>::type, Clear_Helper, sm_domain>
    552. 

  552. {
    553. 

  553.     Clear_Helper(){}
    554. 

  554.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    555. 

  555. #ifdef BOOST_MSVC 
    556. 

  556.  ,class Arg6 
    557. 

  557. #endif
    558. 

  558. >
    559. 

  559.     struct In
    560. 

  560.     {
    561. 

  561.         typedef Clear_<Arg1> type;
    562. 

  562.     };
    563. 

  563. };
    564. 

  564. Clear_Helper const clear_;
    565. 

  565. 

  566. template <class Container>
    567. 

  567. struct ListReverse_ : euml_action<ListReverse_<Container> >
    568. 

  568. {
    569. 

  569.     template <class Event,class FSM,class STATE >
    570. 

  570.     struct state_action_result 
    571. 

  571.     {
    572. 

  572.         typedef void type;
    573. 

  573.     };
    574. 

  574.     template <class EVT,class FSM,class SourceState,class TargetState>
    575. 

  575.     struct transition_action_result 
    576. 

  576.     {
    577. 

  577.         typedef void type;
    578. 

  578.     };
    579. 

  579.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    580. 

  580. 

  581.     template <class EVT,class FSM,class SourceState,class TargetState> 
    582. 

  582.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    583. 

  583.     {
    584. 

  584.         (Container()(evt,fsm,src,tgt)).reverse();
    585. 

  585.     }
    586. 

  586.     template <class Event,class FSM,class STATE>
    587. 

  587.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    588. 

  588.     {
    589. 

  589.         (Container()(evt,fsm,state)).reverse();        
    590. 

  590.     }
    591. 

  591. };
    592. 

  592. struct list_reverse_tag {};
    593. 

  593. struct ListReverse_Helper: proto::extends< proto::terminal<list_reverse_tag>::type, ListReverse_Helper, sm_domain>
    594. 

  594. {
    595. 

  595.     ListReverse_Helper(){}
    596. 

  596.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    597. 

  597. #ifdef BOOST_MSVC 
    598. 

  598.  ,class Arg6 
    599. 

  599. #endif
    600. 

  600. >
    601. 

  601.     struct In
    602. 

  602.     {
    603. 

  603.         typedef ListReverse_<Arg1> type;
    604. 

  604.     };
    605. 

  605. };
    606. 

  606. ListReverse_Helper const list_reverse_;
    607. 

  607. 

  608. template <class Container, class Predicate, class Enable=void>
    609. 

  609. struct ListUnique_ : euml_action<ListUnique_<Container,Predicate,Enable> >
    610. 

  610. {
    611. 

  611.     template <class Event,class FSM,class STATE >
    612. 

  612.     struct state_action_result 
    613. 

  613.     {
    614. 

  614.         typedef void type;
    615. 

  615.     };
    616. 

  616.     template <class EVT,class FSM,class SourceState,class TargetState>
    617. 

  617.     struct transition_action_result 
    618. 

  618.     {
    619. 

  619.         typedef void type;
    620. 

  620.     };
    621. 

  621.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    622. 

  622. 

  623.     template <class EVT,class FSM,class SourceState,class TargetState> 
    624. 

  624.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    625. 

  625.     {
    626. 

  626.         (Container()(evt,fsm,src,tgt)).unique();
    627. 

  627.     }
    628. 

  628.     template <class Event,class FSM,class STATE>
    629. 

  629.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    630. 

  630.     {
    631. 

  631.         (Container()(evt,fsm,state)).unique();        
    632. 

  632.     }
    633. 

  633. };
    634. 

  634. template <class Container, class Predicate >
    635. 

  635. struct ListUnique_<Container,Predicate,
    636. 

  636.                typename ::boost::disable_if<typename ::boost::is_same<Predicate,void>::type >::type> 
    637. 

  637.                     : euml_action<ListUnique_<Container,Predicate> >
    638. 

  638. {
    639. 

  639.     template <class Event,class FSM,class STATE >
    640. 

  640.     struct state_action_result 
    641. 

  641.     {
    642. 

  642.         typedef void type;
    643. 

  643.     };
    644. 

  644.     template <class EVT,class FSM,class SourceState,class TargetState>
    645. 

  645.     struct transition_action_result 
    646. 

  646.     {
    647. 

  647.         typedef void type;
    648. 

  648.     };
    649. 

  649.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    650. 

  650. 

  651.     template <class EVT,class FSM,class SourceState,class TargetState> 
    652. 

  652.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    653. 

  653.     {
    654. 

  654.         (Container()(evt,fsm,src,tgt)).unique(Predicate()(evt,fsm,src,tgt));
    655. 

  655.     }
    656. 

  656.     template <class Event,class FSM,class STATE>
    657. 

  657.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    658. 

  658.     {
    659. 

  659.         (Container()(evt,fsm,state)).unique(Predicate()(evt,fsm,state));        
    660. 

  660.     }
    661. 

  661. };
    662. 

  662. struct list_unique_tag {};
    663. 

  663. struct ListUnique_Helper: proto::extends< proto::terminal<list_unique_tag>::type, ListUnique_Helper, sm_domain>
    664. 

  664. {
    665. 

  665.     ListUnique_Helper(){}
    666. 

  666.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    667. 

  667. #ifdef BOOST_MSVC 
    668. 

  668.  ,class Arg6 
    669. 

  669. #endif
    670. 

  670. >
    671. 

  671.     struct In
    672. 

  672.     {
    673. 

  673.         typedef ListUnique_<Arg1,Arg2> type;
    674. 

  674.     };
    675. 

  675. };
    676. 

  676. ListUnique_Helper const list_unique_;
    677. 

  677. 

  678. template <class Container, class Predicate, class Enable=void>
    679. 

  679. struct ListSort_ : euml_action<ListSort_<Container,Predicate,Enable> >
    680. 

  680. {
    681. 

  681.     template <class Event,class FSM,class STATE >
    682. 

  682.     struct state_action_result 
    683. 

  683.     {
    684. 

  684.         typedef void type;
    685. 

  685.     };
    686. 

  686.     template <class EVT,class FSM,class SourceState,class TargetState>
    687. 

  687.     struct transition_action_result 
    688. 

  688.     {
    689. 

  689.         typedef void type;
    690. 

  690.     };
    691. 

  691.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    692. 

  692. 

  693.     template <class EVT,class FSM,class SourceState,class TargetState> 
    694. 

  694.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    695. 

  695.     {
    696. 

  696.         (Container()(evt,fsm,src,tgt)).sort();
    697. 

  697.     }
    698. 

  698.     template <class Event,class FSM,class STATE>
    699. 

  699.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    700. 

  700.     {
    701. 

  701.         (Container()(evt,fsm,state)).sort();        
    702. 

  702.     }
    703. 

  703. };
    704. 

  704. template <class Container, class Predicate >
    705. 

  705. struct ListSort_<Container,Predicate,
    706. 

  706.                typename ::boost::disable_if<typename ::boost::is_same<Predicate,void>::type >::type> 
    707. 

  707.                     : euml_action<ListSort_<Container,Predicate> >
    708. 

  708. {
    709. 

  709.     template <class Event,class FSM,class STATE >
    710. 

  710.     struct state_action_result 
    711. 

  711.     {
    712. 

  712.         typedef void type;
    713. 

  713.     };
    714. 

  714.     template <class EVT,class FSM,class SourceState,class TargetState>
    715. 

  715.     struct transition_action_result 
    716. 

  716.     {
    717. 

  717.         typedef void type;
    718. 

  718.     };
    719. 

  719.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    720. 

  720. 

  721.     template <class EVT,class FSM,class SourceState,class TargetState> 
    722. 

  722.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    723. 

  723.     {
    724. 

  724.         (Container()(evt,fsm,src,tgt)).sort(Predicate()(evt,fsm,src,tgt));
    725. 

  725.     }
    726. 

  726.     template <class Event,class FSM,class STATE>
    727. 

  727.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    728. 

  728.     {
    729. 

  729.         (Container()(evt,fsm,state)).sort(Predicate()(evt,fsm,state));        
    730. 

  730.     }
    731. 

  731. };
    732. 

  732. struct list_sort_tag {};
    733. 

  733. struct ListSort_Helper: proto::extends< proto::terminal<list_sort_tag>::type, ListSort_Helper, sm_domain>
    734. 

  734. {
    735. 

  735.     ListSort_Helper(){}
    736. 

  736.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    737. 

  737. #ifdef BOOST_MSVC 
    738. 

  738.  ,class Arg6 
    739. 

  739. #endif
    740. 

  740. >
    741. 

  741.     struct In
    742. 

  742.     {
    743. 

  743.         typedef ListSort_<Arg1,Arg2> type;
    744. 

  744.     };
    745. 

  745. };
    746. 

  746. ListSort_Helper const list_sort_;
    747. 

  747. 

  748. template <class Container>
    749. 

  749. struct Capacity_ : euml_action<Capacity_<Container> >
    750. 

  750. {
    751. 

  751.     template <class Event,class FSM,class STATE >
    752. 

  752.     struct state_action_result 
    753. 

  753.     {
    754. 

  754.         typedef typename get_size_type< 
    755. 

  755.             typename ::boost::remove_reference<
    756. 

  756.                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
    757. 

  757.     };
    758. 

  758.     template <class EVT,class FSM,class SourceState,class TargetState>
    759. 

  759.     struct transition_action_result 
    760. 

  760.     {
    761. 

  761.         typedef typename get_size_type< 
    762. 

  762.             typename ::boost::remove_reference<
    763. 

  763.                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    764. 

  764.     };
    765. 

  765.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    766. 

  766. 

  767.     template <class EVT,class FSM,class SourceState,class TargetState>
    768. 

  768.     typename ::boost::enable_if<
    769. 

  769.         typename ::boost::mpl::has_key<
    770. 

  770.             typename Container::tag_type,action_tag>::type,
    771. 

  771.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    772. 

  772.      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    773. 

  773.     {
    774. 

  774.         return (Container()(evt,fsm,src,tgt)).capacity();
    775. 

  775.     }
    776. 

  776.     template <class Event,class FSM,class STATE>
    777. 

  777.     typename ::boost::enable_if<
    778. 

  778.         typename ::boost::mpl::has_key<
    779. 

  779.             typename Container::tag_type,state_action_tag>::type,
    780. 

  780.             typename state_action_result<Event,FSM,STATE>::type >::type 
    781. 

  781.      operator()(Event const& evt,FSM& fsm,STATE& state )const
    782. 

  782.     {
    783. 

  783.         return (Container()(evt,fsm,state)).capacity();        
    784. 

  784.     }
    785. 

  785. };
    786. 

  786. struct capacity_tag {};
    787. 

  787. struct Capacity_Helper: proto::extends< proto::terminal<capacity_tag>::type, Capacity_Helper, sm_domain>
    788. 

  788. {
    789. 

  789.     Capacity_Helper(){}
    790. 

  790.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    791. 

  791. #ifdef BOOST_MSVC 
    792. 

  792.  ,class Arg6 
    793. 

  793. #endif
    794. 

  794. >
    795. 

  795.     struct In
    796. 

  796.     {
    797. 

  797.         typedef Capacity_<Arg1> type;
    798. 

  798.     };
    799. 

  799. };
    800. 

  800. Capacity_Helper const capacity_;
    801. 

  801. 

  802. template <class Container>
    803. 

  803. struct Size_ : euml_action<Size_<Container> >
    804. 

  804. {
    805. 

  805.     template <class Event,class FSM,class STATE >
    806. 

  806.     struct state_action_result 
    807. 

  807.     {
    808. 

  808.         typedef typename get_size_type< 
    809. 

  809.             typename ::boost::remove_reference<
    810. 

  810.                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
    811. 

  811.     };
    812. 

  812.     template <class EVT,class FSM,class SourceState,class TargetState>
    813. 

  813.     struct transition_action_result 
    814. 

  814.     {
    815. 

  815.         typedef typename get_size_type< 
    816. 

  816.             typename ::boost::remove_reference<
    817. 

  817.                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    818. 

  818.     };
    819. 

  819.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    820. 

  820. 

  821.     template <class EVT,class FSM,class SourceState,class TargetState>
    822. 

  822.     typename ::boost::enable_if<
    823. 

  823.         typename ::boost::mpl::has_key<
    824. 

  824.             typename Container::tag_type,action_tag>::type,
    825. 

  825.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    826. 

  826.      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    827. 

  827.     {
    828. 

  828.         return (Container()(evt,fsm,src,tgt)).size();
    829. 

  829.     }
    830. 

  830.     template <class Event,class FSM,class STATE>
    831. 

  831.     typename ::boost::enable_if<
    832. 

  832.         typename ::boost::mpl::has_key<
    833. 

  833.             typename Container::tag_type,state_action_tag>::type,
    834. 

  834.             typename state_action_result<Event,FSM,STATE>::type >::type 
    835. 

  835.      operator()(Event const& evt,FSM& fsm,STATE& state )const
    836. 

  836.     {
    837. 

  837.         return (Container()(evt,fsm,state)).size();        
    838. 

  838.     }
    839. 

  839. };
    840. 

  840. struct size_tag {};
    841. 

  841. struct Size_Helper: proto::extends< proto::terminal<size_tag>::type, Size_Helper, sm_domain>
    842. 

  842. {
    843. 

  843.     Size_Helper(){}
    844. 

  844.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    845. 

  845. #ifdef BOOST_MSVC 
    846. 

  846.  ,class Arg6 
    847. 

  847. #endif
    848. 

  848. >
    849. 

  849.     struct In
    850. 

  850.     {
    851. 

  851.         typedef Size_<Arg1> type;
    852. 

  852.     };
    853. 

  853. };
    854. 

  854. Size_Helper const size_;
    855. 

  855. 

  856. template <class Container>
    857. 

  857. struct Max_Size_ : euml_action<Max_Size_<Container> >
    858. 

  858. {
    859. 

  859.     template <class Event,class FSM,class STATE >
    860. 

  860.     struct state_action_result 
    861. 

  861.     {
    862. 

  862.         typedef typename get_size_type< 
    863. 

  863.             typename ::boost::remove_reference<
    864. 

  864.                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
    865. 

  865.     };
    866. 

  866.     template <class EVT,class FSM,class SourceState,class TargetState>
    867. 

  867.     struct transition_action_result 
    868. 

  868.     {
    869. 

  869.         typedef typename get_size_type< 
    870. 

  870.             typename ::boost::remove_reference<
    871. 

  871.                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    872. 

  872.     };
    873. 

  873.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    874. 

  874. 

  875.     template <class EVT,class FSM,class SourceState,class TargetState>
    876. 

  876.     typename ::boost::enable_if<
    877. 

  877.         typename ::boost::mpl::has_key<
    878. 

  878.             typename Container::tag_type,action_tag>::type,
    879. 

  879.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    880. 

  880.      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    881. 

  881.     {
    882. 

  882.         return (Container()(evt,fsm,src,tgt)).max_size();
    883. 

  883.     }
    884. 

  884.     template <class Event,class FSM,class STATE>
    885. 

  885.     typename ::boost::enable_if<
    886. 

  886.         typename ::boost::mpl::has_key<
    887. 

  887.             typename Container::tag_type,state_action_tag>::type,
    888. 

  888.             typename state_action_result<Event,FSM,STATE>::type >::type 
    889. 

  889.      operator()(Event const& evt,FSM& fsm,STATE& state )const
    890. 

  890.     {
    891. 

  891.         return (Container()(evt,fsm,state)).max_size();        
    892. 

  892.     }
    893. 

  893. };
    894. 

  894. struct max_size_tag {};
    895. 

  895. struct Max_Size_Helper: proto::extends< proto::terminal<max_size_tag>::type, Max_Size_Helper, sm_domain>
    896. 

  896. {
    897. 

  897.     Max_Size_Helper(){}
    898. 

  898.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    899. 

  899. #ifdef BOOST_MSVC 
    900. 

  900.  ,class Arg6 
    901. 

  901. #endif
    902. 

  902. >
    903. 

  903.     struct In
    904. 

  904.     {
    905. 

  905.         typedef Max_Size_<Arg1> type;
    906. 

  906.     };
    907. 

  907. };
    908. 

  908. Max_Size_Helper const max_size_;
    909. 

  909. 

  910. template <class Container, class Value>
    911. 

  911. struct Reserve_ : euml_action<Reserve_<Container,Value> >
    912. 

  912. {
    913. 

  913.     template <class Event,class FSM,class STATE >
    914. 

  914.     struct state_action_result 
    915. 

  915.     {
    916. 

  916.         typedef void type;
    917. 

  917.     };
    918. 

  918.     template <class EVT,class FSM,class SourceState,class TargetState>
    919. 

  919.     struct transition_action_result 
    920. 

  920.     {
    921. 

  921.         typedef void type;
    922. 

  922.     };
    923. 

  923.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    924. 

  924. 

  925.     template <class EVT,class FSM,class SourceState,class TargetState> 
    926. 

  926.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    927. 

  927.     {
    928. 

  928.         (Container()(evt,fsm,src,tgt)).reserve(Value()(evt,fsm,src,tgt));
    929. 

  929.     }
    930. 

  930.     template <class Event,class FSM,class STATE>
    931. 

  931.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    932. 

  932.     {
    933. 

  933.         (Container()(evt,fsm,state)).reserve(Value()(evt,fsm,state));        
    934. 

  934.     }
    935. 

  935. };
    936. 

  936. struct reserve_tag {};
    937. 

  937. struct Reserve_Helper: proto::extends< proto::terminal<reserve_tag>::type, Reserve_Helper, sm_domain>
    938. 

  938. {
    939. 

  939.     Reserve_Helper(){}
    940. 

  940.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    941. 

  941. #ifdef BOOST_MSVC 
    942. 

  942.  ,class Arg6 
    943. 

  943. #endif
    944. 

  944. >
    945. 

  945.     struct In
    946. 

  946.     {
    947. 

  947.         typedef Reserve_<Arg1,Arg2> type;
    948. 

  948.     };
    949. 

  949. };
    950. 

  950. Reserve_Helper const reserve_;
    951. 

  951. 

  952. template <class Container, class Num, class Value ,class Enable=void >
    953. 

  953. struct Resize_ : euml_action<Resize_<Container,Num,Value> >
    954. 

  954. {
    955. 

  955.     template <class Event,class FSM,class STATE >
    956. 

  956.     struct state_action_result 
    957. 

  957.     {
    958. 

  958.         typedef void type;
    959. 

  959.     };
    960. 

  960.     template <class EVT,class FSM,class SourceState,class TargetState>
    961. 

  961.     struct transition_action_result 
    962. 

  962.     {
    963. 

  963.         typedef void type;
    964. 

  964.     };
    965. 

  965.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    966. 

  966. 

  967.     template <class EVT,class FSM,class SourceState,class TargetState> 
    968. 

  968.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    969. 

  969.     {
    970. 

  970.         (Container()(evt,fsm,src,tgt)).resize(Num()(evt,fsm,src,tgt));
    971. 

  971.     }
    972. 

  972.     template <class Event,class FSM,class STATE>
    973. 

  973.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    974. 

  974.     {
    975. 

  975.         (Container()(evt,fsm,state)).resize(Num()(evt,fsm,state));        
    976. 

  976.     }
    977. 

  977. };
    978. 

  978. template <class Container, class Num , class Value >
    979. 

  979. struct Resize_<Container,Num,Value,typename ::boost::disable_if<typename ::boost::is_same<Value,void>::type >::type> 
    980. 

  980.                     : euml_action<Resize_<Container,Num,Value> >
    981. 

  981. {
    982. 

  982.     template <class Event,class FSM,class STATE >
    983. 

  983.     struct state_action_result 
    984. 

  984.     {
    985. 

  985.         typedef void type;
    986. 

  986.     };
    987. 

  987.     template <class EVT,class FSM,class SourceState,class TargetState>
    988. 

  988.     struct transition_action_result 
    989. 

  989.     {
    990. 

  990.         typedef void type;
    991. 

  991.     };
    992. 

  992.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    993. 

  993. 

  994.     template <class EVT,class FSM,class SourceState,class TargetState> 
    995. 

  995.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    996. 

  996.     {
    997. 

  997.         (Container()(evt,fsm,src,tgt)).resize(Num()(evt,fsm,src,tgt),Value()(evt,fsm,src,tgt));
    998. 

  998.     }
    999. 

  999.     template <class Event,class FSM,class STATE>
    1000. 

  1000.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    1001. 

  1001.     {
    1002. 

  1002.         (Container()(evt,fsm,state)).resize(Num()(evt,fsm,state),Value()(evt,fsm,state));
    1003. 

  1003.     }
    1004. 

  1004. };
    1005. 

  1005. struct resize_tag {};
    1006. 

  1006. struct Resize_Helper: proto::extends< proto::terminal<resize_tag>::type, Resize_Helper, sm_domain>
    1007. 

  1007. {
    1008. 

  1008.     Resize_Helper(){}
    1009. 

  1009.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    1010. 

  1010. #ifdef BOOST_MSVC 
    1011. 

  1011.  ,class Arg6 
    1012. 

  1012. #endif
    1013. 

  1013. >
    1014. 

  1014.     struct In
    1015. 

  1015.     {
    1016. 

  1016.         typedef Resize_<Arg1,Arg2,Arg3> type;
    1017. 

  1017.     };
    1018. 

  1018. };
    1019. 

  1019. Resize_Helper const resize_;
    1020. 

  1020. 

  1021. // version for 3 parameters (sequence containers)
    1022. 

  1022. template <class Container, class Param1, class Param2, class Param3 >
    1023. 

  1023. struct Insert_ : euml_action<Insert_<Container,Param1,Param2,Param3> >
    1024. 

  1024. {
    1025. 

  1025.     template <class Event,class FSM,class STATE >
    1026. 

  1026.     struct state_action_result 
    1027. 

  1027.     {
    1028. 

  1028.         typedef void type;
    1029. 

  1029.     };
    1030. 

  1030.     template <class EVT,class FSM,class SourceState,class TargetState>
    1031. 

  1031.     struct transition_action_result 
    1032. 

  1032.     {
    1033. 

  1033.         typedef void type;
    1034. 

  1034.     };
    1035. 

  1035.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1036. 

  1036. 

  1037.     template <class EVT,class FSM,class SourceState,class TargetState> 
    1038. 

  1038.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1039. 

  1039.     {
    1040. 

  1040.         (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt),
    1041. 

  1041.                                               Param3()(evt,fsm,src,tgt));
    1042. 

  1042.     }
    1043. 

  1043.     template <class Event,class FSM,class STATE>
    1044. 

  1044.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    1045. 

  1045.     {
    1046. 

  1046.         (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state),
    1047. 

  1047.                                             Param3()(evt,fsm,state));
    1048. 

  1048.     }
    1049. 

  1049. };
    1050. 

  1050. // version for 2 parameters
    1051. 

  1051. template <class Container, class Param1, class Param2>
    1052. 

  1052. struct Insert_ < Container,Param1,Param2,void>
    1053. 

  1053.     : euml_action<Insert_<Container,Param1,Param2,void> >
    1054. 

  1054. {
    1055. 

  1055.     // return value will actually not be correct for set::insert(it1,it2), should be void
    1056. 

  1056.     // but it's ok as nobody should call an inexistent return type
    1057. 

  1057.     template <class Event,class FSM,class STATE >
    1058. 

  1058.     struct state_action_result 
    1059. 

  1059.     {
    1060. 

  1060.         typedef typename get_iterator< 
    1061. 

  1061.             typename ::boost::remove_reference<
    1062. 

  1062.                 typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type type;
    1063. 

  1063.     };
    1064. 

  1064.     template <class EVT,class FSM,class SourceState,class TargetState>
    1065. 

  1065.     struct transition_action_result 
    1066. 

  1066.     {
    1067. 

  1067.         typedef typename get_iterator< 
    1068. 

  1068.             typename ::boost::remove_reference<
    1069. 

  1069.                 typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type type;
    1070. 

  1070.     };
    1071. 

  1071.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1072. 

  1072. 

  1073.     // version for transition + second param not an iterator (meaning that, Container is not an associative container)
    1074. 

  1074.     template <class EVT,class FSM,class SourceState,class TargetState>
    1075. 

  1075.     typename ::boost::enable_if<
    1076. 

  1076.         typename ::boost::mpl::and_<
    1077. 

  1077.             typename ::boost::mpl::has_key<
    1078. 

  1078.                 typename Container::tag_type,action_tag>::type,
    1079. 

  1079.                 typename ::boost::mpl::not_<
    1080. 

  1080.                     typename has_iterator_category<
    1081. 

  1081.                         typename Param2::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
    1082. 

  1082.                     >::type
    1083. 

  1083.                    >::type
    1084. 

  1084.                 >::type,
    1085. 

  1085.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
    1086. 

  1086.         >::type 
    1087. 

  1087.      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1088. 

  1088.     {
    1089. 

  1089.         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
    1090. 

  1090.     }
    1091. 

  1091. 

  1092.     // version for transition + second param is an iterator (meaning that, Container is an associative container)
    1093. 

  1093.     template <class EVT,class FSM,class SourceState,class TargetState>
    1094. 

  1094.     typename ::boost::enable_if<
    1095. 

  1095.         typename ::boost::mpl::and_<
    1096. 

  1096.             typename ::boost::mpl::has_key<
    1097. 

  1097.                 typename Container::tag_type,action_tag>::type,
    1098. 

  1098.                     typename has_iterator_category<
    1099. 

  1099.                         typename Param2::template transition_action_result<EVT,FSM,SourceState,TargetState>::type
    1100. 

  1100.                     >::type
    1101. 

  1101.                 >::type,
    1102. 

  1102.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
    1103. 

  1103.         >::type 
    1104. 

  1104.      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1105. 

  1105.     {
    1106. 

  1106.         (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt),Param2()(evt,fsm,src,tgt));
    1107. 

  1107.     }
    1108. 

  1108. 

  1109.     // version for state action + second param not an iterator (meaning that, Container is not an associative container)
    1110. 

  1110.     template <class Event,class FSM,class STATE>
    1111. 

  1111.     typename ::boost::enable_if<
    1112. 

  1112.         typename ::boost::mpl::and_<
    1113. 

  1113.             typename ::boost::mpl::has_key<
    1114. 

  1114.                 typename Container::tag_type,state_action_tag>::type,
    1115. 

  1115.                 typename ::boost::mpl::not_<
    1116. 

  1116.                     typename has_iterator_category<
    1117. 

  1117.                         typename Param2::template state_action_result<Event,FSM,STATE>::type
    1118. 

  1118.                     >::type
    1119. 

  1119.                    >::type
    1120. 

  1120.                 >::type,
    1121. 

  1121.             typename state_action_result<Event,FSM,STATE>::type 
    1122. 

  1122.         >::type  
    1123. 

  1123.      operator()(Event const& evt,FSM& fsm,STATE& state )const
    1124. 

  1124.     {
    1125. 

  1125.         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));        
    1126. 

  1126.     }
    1127. 

  1127. 

  1128.     // version for state action + second param is an iterator (meaning that, Container is an associative container)
    1129. 

  1129.     template <class Event,class FSM,class STATE>
    1130. 

  1130.     typename ::boost::enable_if<
    1131. 

  1131.         typename ::boost::mpl::and_<
    1132. 

  1132.             typename ::boost::mpl::has_key<
    1133. 

  1133.                 typename Container::tag_type,state_action_tag>::type,
    1134. 

  1134.                     typename has_iterator_category<
    1135. 

  1135.                         typename Param2::template state_action_result<Event,FSM,STATE>::type
    1136. 

  1136.                     >::type
    1137. 

  1137.                 >::type,
    1138. 

  1138.             typename state_action_result<Event,FSM,STATE>::type 
    1139. 

  1139.         >::type 
    1140. 

  1140.      operator()(Event const& evt,FSM& fsm,STATE& state )const
    1141. 

  1141.     {
    1142. 

  1142.         (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state),Param2()(evt,fsm,state));        
    1143. 

  1143.     }
    1144. 

  1144. };
    1145. 

  1145. 

  1146. // version for 1 parameter (associative containers)
    1147. 

  1147. template <class Container, class Param1>
    1148. 

  1148. struct Insert_ < Container,Param1,void,void>
    1149. 

  1149.     : euml_action<Insert_<Container,Param1,void,void> >
    1150. 

  1150. {
    1151. 

  1151.     template <class Event,class FSM,class STATE >
    1152. 

  1152.     struct state_action_result 
    1153. 

  1153.     {
    1154. 

  1154.         typedef typename std::pair<
    1155. 

  1155.             typename get_iterator< 
    1156. 

  1156.                 typename ::boost::remove_reference<
    1157. 

  1157.                     typename get_result_type2<Container,Event,FSM,STATE>::type>::type>::type,bool> type;
    1158. 

  1158.     };
    1159. 

  1159.     template <class EVT,class FSM,class SourceState,class TargetState>
    1160. 

  1160.     struct transition_action_result 
    1161. 

  1161.     {
    1162. 

  1162.         typedef typename std::pair<
    1163. 

  1163.             typename get_iterator< 
    1164. 

  1164.                 typename ::boost::remove_reference<
    1165. 

  1165.                     typename get_result_type<Container,EVT,FSM,SourceState,TargetState>::type>::type>::type,bool> type;
    1166. 

  1166.     };
    1167. 

  1167.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1168. 

  1168. 

  1169.     template <class EVT,class FSM,class SourceState,class TargetState>
    1170. 

  1170.     typename ::boost::enable_if<
    1171. 

  1171.         typename ::boost::mpl::has_key<
    1172. 

  1172.             typename Container::tag_type,action_tag>::type,
    1173. 

  1173.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    1174. 

  1174.      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1175. 

  1175.     {
    1176. 

  1176.         return (Container()(evt,fsm,src,tgt)).insert(Param1()(evt,fsm,src,tgt));
    1177. 

  1177.     }
    1178. 

  1178.     template <class Event,class FSM,class STATE>
    1179. 

  1179.     typename ::boost::enable_if<
    1180. 

  1180.         typename ::boost::mpl::has_key<
    1181. 

  1181.             typename Container::tag_type,state_action_tag>::type,
    1182. 

  1182.             typename state_action_result<Event,FSM,STATE>::type >::type 
    1183. 

  1183.      operator()(Event const& evt,FSM& fsm,STATE& state )const
    1184. 

  1184.     {
    1185. 

  1185.         return (Container()(evt,fsm,state)).insert(Param1()(evt,fsm,state));        
    1186. 

  1186.     }
    1187. 

  1187. };
    1188. 

  1188. struct insert_tag {};
    1189. 

  1189. struct Insert_Helper: proto::extends< proto::terminal<insert_tag>::type, Insert_Helper, sm_domain>
    1190. 

  1190. {
    1191. 

  1191.     Insert_Helper(){}
    1192. 

  1192.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    1193. 

  1193. #ifdef BOOST_MSVC 
    1194. 

  1194.  ,class Arg6 
    1195. 

  1195. #endif
    1196. 

  1196. >
    1197. 

  1197.     struct In
    1198. 

  1198.     {
    1199. 

  1199.         typedef Insert_<Arg1,Arg2,Arg3,Arg4> type;
    1200. 

  1200.     };
    1201. 

  1201. };
    1202. 

  1202. Insert_Helper const insert_;
    1203. 

  1203. 

  1204. template <class Container1,class Container2>
    1205. 

  1205. struct Swap_ : euml_action<Swap_<Container1,Container2> >
    1206. 

  1206. {
    1207. 

  1207.     template <class Event,class FSM,class STATE >
    1208. 

  1208.     struct state_action_result 
    1209. 

  1209.     {
    1210. 

  1210.         typedef void type;
    1211. 

  1211.     };
    1212. 

  1212.     template <class EVT,class FSM,class SourceState,class TargetState>
    1213. 

  1213.     struct transition_action_result 
    1214. 

  1214.     {
    1215. 

  1215.         typedef void type;
    1216. 

  1216.     };
    1217. 

  1217.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1218. 

  1218. 

  1219.     template <class EVT,class FSM,class SourceState,class TargetState> 
    1220. 

  1220.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1221. 

  1221.     {
    1222. 

  1222.         (Container1()(evt,fsm,src,tgt)).swap(Container2()(evt,fsm,src,tgt));
    1223. 

  1223.     }
    1224. 

  1224.     template <class Event,class FSM,class STATE>
    1225. 

  1225.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    1226. 

  1226.     {
    1227. 

  1227.         (Container1()(evt,fsm,state)).swap(Container2()(evt,fsm,state));        
    1228. 

  1228.     }
    1229. 

  1229. };
    1230. 

  1230. struct swap_tag {};
    1231. 

  1231. struct Swap_Helper: proto::extends< proto::terminal<swap_tag>::type, Swap_Helper, sm_domain>
    1232. 

  1232. {
    1233. 

  1233.     Swap_Helper(){}
    1234. 

  1234.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    1235. 

  1235. #ifdef BOOST_MSVC 
    1236. 

  1236.  ,class Arg6 
    1237. 

  1237. #endif
    1238. 

  1238. >
    1239. 

  1239.     struct In
    1240. 

  1240.     {
    1241. 

  1241.         typedef Swap_<Arg1,Arg2> type;
    1242. 

  1242.     };
    1243. 

  1243. };
    1244. 

  1244. Swap_Helper const swap_;
    1245. 

  1245. 

  1246. template <class Container, class Iterator1, class Iterator2 ,class Enable=void >
    1247. 

  1247. struct Erase_ : euml_action<Erase_<Container,Iterator1,Iterator2> >
    1248. 

  1248. {
    1249. 

  1249.     template <class Event,class FSM,class STATE >
    1250. 

  1250.     struct state_action_result 
    1251. 

  1251.     {
    1252. 

  1252.         typedef typename get_result_type2<Iterator1,Event,FSM,STATE>::type type;
    1253. 

  1253.     };
    1254. 

  1254.     template <class EVT,class FSM,class SourceState,class TargetState>
    1255. 

  1255.     struct transition_action_result 
    1256. 

  1256.     {
    1257. 

  1257.         typedef typename get_result_type<Iterator1,EVT,FSM,SourceState,TargetState>::type type;
    1258. 

  1258.     };
    1259. 

  1259.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1260. 

  1260. 

  1261.     template <class EVT,class FSM,class SourceState,class TargetState> 
    1262. 

  1262.     typename ::boost::enable_if<
    1263. 

  1263.         typename ::boost::mpl::has_key<
    1264. 

  1264.             typename Iterator1::tag_type,action_tag>::type,
    1265. 

  1265.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    1266. 

  1266.     operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1267. 

  1267.     {
    1268. 

  1268.         return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt));
    1269. 

  1269.     }
    1270. 

  1270.     template <class Event,class FSM,class STATE>
    1271. 

  1271.     typename ::boost::enable_if<
    1272. 

  1272.         typename ::boost::mpl::has_key<
    1273. 

  1273.             typename Iterator1::tag_type,state_action_tag>::type,
    1274. 

  1274.             typename state_action_result<Event,FSM,STATE>::type >::type 
    1275. 

  1275.     operator()(Event const& evt,FSM& fsm,STATE& state )const
    1276. 

  1276.     {
    1277. 

  1277.         return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state));        
    1278. 

  1278.     }
    1279. 

  1279. };
    1280. 

  1280. template <class Container, class Iterator1 , class Iterator2 >
    1281. 

  1281. struct Erase_<Container,Iterator1,Iterator2,
    1282. 

  1282.               typename ::boost::disable_if<typename ::boost::is_same<Iterator2,void>::type >::type> 
    1283. 

  1283.                     : euml_action<Erase_<Container,Iterator1,Iterator2> >
    1284. 

  1284. {
    1285. 

  1285.     template <class Event,class FSM,class STATE >
    1286. 

  1286.     struct state_action_result 
    1287. 

  1287.     {
    1288. 

  1288.         typedef typename get_result_type2<Iterator1,Event,FSM,STATE>::type type;
    1289. 

  1289.     };
    1290. 

  1290.     template <class EVT,class FSM,class SourceState,class TargetState>
    1291. 

  1291.     struct transition_action_result 
    1292. 

  1292.     {
    1293. 

  1293.         typedef typename get_result_type<Iterator1,EVT,FSM,SourceState,TargetState>::type type;
    1294. 

  1294.     };
    1295. 

  1295.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1296. 

  1296. 

  1297.     template <class EVT,class FSM,class SourceState,class TargetState> 
    1298. 

  1298.     typename ::boost::enable_if<
    1299. 

  1299.         typename ::boost::mpl::has_key<
    1300. 

  1300.             typename Iterator1::tag_type,action_tag>::type,
    1301. 

  1301.             typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
    1302. 

  1302.     operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1303. 

  1303.     {
    1304. 

  1304.         return (Container()(evt,fsm,src,tgt)).erase(Iterator1()(evt,fsm,src,tgt),Iterator2()(evt,fsm,src,tgt));
    1305. 

  1305.     }
    1306. 

  1306.     template <class Event,class FSM,class STATE>
    1307. 

  1307.     typename ::boost::enable_if<
    1308. 

  1308.         typename ::boost::mpl::has_key<
    1309. 

  1309.             typename Iterator1::tag_type,state_action_tag>::type,
    1310. 

  1310.             typename state_action_result<Event,FSM,STATE>::type >::type 
    1311. 

  1311.     operator()(Event const& evt,FSM& fsm,STATE& state )const
    1312. 

  1312.     {
    1313. 

  1313.         return (Container()(evt,fsm,state)).erase(Iterator1()(evt,fsm,state),Iterator2()(evt,fsm,state));        
    1314. 

  1314.     }
    1315. 

  1315. };
    1316. 

  1316. struct erase_tag {};
    1317. 

  1317. struct Erase_Helper: proto::extends< proto::terminal<erase_tag>::type, Erase_Helper, sm_domain>
    1318. 

  1318. {
    1319. 

  1319.     Erase_Helper(){}
    1320. 

  1320.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    1321. 

  1321. #ifdef BOOST_MSVC 
    1322. 

  1322.  ,class Arg6 
    1323. 

  1323. #endif
    1324. 

  1324. >
    1325. 

  1325.     struct In
    1326. 

  1326.     {
    1327. 

  1327.         typedef Erase_<Arg1,Arg2,Arg3> type;
    1328. 

  1328.     };
    1329. 

  1329. };
    1330. 

  1330. Erase_Helper const erase_;
    1331. 

  1331. 

  1332. template <class Container>
    1333. 

  1333. struct Empty_ : euml_action<Empty_<Container> >
    1334. 

  1334. {
    1335. 

  1335.     template <class Event,class FSM,class STATE >
    1336. 

  1336.     struct state_action_result 
    1337. 

  1337.     {
    1338. 

  1338.         typedef bool type;
    1339. 

  1339.     };
    1340. 

  1340.     template <class EVT,class FSM,class SourceState,class TargetState>
    1341. 

  1341.     struct transition_action_result 
    1342. 

  1342.     {
    1343. 

  1343.         typedef bool type;
    1344. 

  1344.     };
    1345. 

  1345.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1346. 

  1346. 

  1347.     template <class EVT,class FSM,class SourceState,class TargetState> 
    1348. 

  1348.     bool operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1349. 

  1349.     {
    1350. 

  1350.         return (Container()(evt,fsm,src,tgt)).empty();
    1351. 

  1351.     }
    1352. 

  1352.     template <class Event,class FSM,class STATE>
    1353. 

  1353.     bool operator()(Event const& evt,FSM& fsm,STATE& state )const
    1354. 

  1354.     {
    1355. 

  1355.         return (Container()(evt,fsm,state)).empty();        
    1356. 

  1356.     }
    1357. 

  1357. };
    1358. 

  1358. struct empty_tag {};
    1359. 

  1359. struct Empty_Helper: proto::extends< proto::terminal<empty_tag>::type, Empty_Helper, sm_domain>
    1360. 

  1360. {
    1361. 

  1361.     Empty_Helper(){}
    1362. 

  1362.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    1363. 

  1363. #ifdef BOOST_MSVC 
    1364. 

  1364.  ,class Arg6 
    1365. 

  1365. #endif
    1366. 

  1366. >
    1367. 

  1367.     struct In
    1368. 

  1368.     {
    1369. 

  1369.         typedef Empty_<Arg1> type;
    1370. 

  1370.     };
    1371. 

  1371. };
    1372. 

  1372. Empty_Helper const empty_;
    1373. 

  1373. 

  1374. template <class Container,class Element>
    1375. 

  1375. struct ListRemove_ : euml_action<ListRemove_<Container,Element> >
    1376. 

  1376. {
    1377. 

  1377.     template <class Event,class FSM,class STATE >
    1378. 

  1378.     struct state_action_result 
    1379. 

  1379.     {
    1380. 

  1380.         typedef void type;
    1381. 

  1381.     };
    1382. 

  1382.     template <class EVT,class FSM,class SourceState,class TargetState>
    1383. 

  1383.     struct transition_action_result 
    1384. 

  1384.     {
    1385. 

  1385.         typedef void type;
    1386. 

  1386.     };
    1387. 

  1387.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1388. 

  1388. 

  1389.     template <class EVT,class FSM,class SourceState,class TargetState> 
    1390. 

  1390.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1391. 

  1391.     {
    1392. 

  1392.         (Container()(evt,fsm,src,tgt)).remove(Element()(evt,fsm,src,tgt));
    1393. 

  1393.     }
    1394. 

  1394.     template <class Event,class FSM,class STATE>
    1395. 

  1395.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    1396. 

  1396.     {
    1397. 

  1397.         (Container()(evt,fsm,state)).remove(Element()(evt,fsm,state));        
    1398. 

  1398.     }
    1399. 

  1399. };
    1400. 

  1400. struct list_remove_tag {};
    1401. 

  1401. struct ListRemove_Helper: proto::extends< proto::terminal<list_remove_tag>::type, ListRemove_Helper, sm_domain>
    1402. 

  1402. {
    1403. 

  1403.     ListRemove_Helper(){}
    1404. 

  1404.     template <class Arg1,class Arg2,class Arg3,class Arg4,class Arg5 
    1405. 

  1405. #ifdef BOOST_MSVC 
    1406. 

  1406.  ,class Arg6 
    1407. 

  1407. #endif
    1408. 

  1408. >
    1409. 

  1409.     struct In
    1410. 

  1410.     {
    1411. 

  1411.         typedef ListRemove_<Arg1,Arg2> type;
    1412. 

  1412.     };
    1413. 

  1413. };
    1414. 

  1414. ListRemove_Helper const list_remove_;
    1415. 

  1415. 

  1416. template <class Container,class Element>
    1417. 

  1417. struct ListRemove_If_ : euml_action<ListRemove_If_<Container,Element> >
    1418. 

  1418. {
    1419. 

  1419.     template <class Event,class FSM,class STATE >
    1420. 

  1420.     struct state_action_result 
    1421. 

  1421.     {
    1422. 

  1422.         typedef void type;
    1423. 

  1423.     };
    1424. 

  1424.     template <class EVT,class FSM,class SourceState,class TargetState>
    1425. 

  1425.     struct transition_action_result 
    1426. 

  1426.     {
    1427. 

  1427.         typedef void type;
    1428. 

  1428.     };
    1429. 

  1429.     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
    1430. 

  1430. 

  1431.     template <class EVT,class FSM,class SourceState,class TargetState> 
    1432. 

  1432.     void operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
    1433. 

  1433.     {
    1434. 

  1434.         (Container()(evt,fsm,src,tgt)).remove_if(Element()(evt,fsm,src,tgt));
    1435. 

  1435.     }
    1436. 

  1436.     template <class Event,class FSM,class STATE>
    1437. 

  1437.     void operator()(Event const& evt,FSM& fsm,STATE& state )const
    1438. 

  1438.     {
    1439. 

  1439.         (Container()(evt,fsm,state)).remove_if(Element()(evt,fsm,state));        
    1440. 

  1440.     }
    1441. 

  1441. };
    1442. 

  1442. struct list_remove_if_tag {};
    1443. 

  1443. struct ListRemove_If_Helper: proto::extends< proto::terminal<list_remove_if_tag>::type, ListRemove_If_Helper, sm_domain>
    1444. 

  1444. {
    1445. 

  1445.     ListRemove_If_Helper(){}
    1446. 

  1446.     template <class Arg1…
    1447.