/src/contrib/boost/spirit/home/classic/phoenix/actor.hpp

http://pythonocc.googlecode.com/ · C++ Header · 604 lines · 400 code · 67 blank · 137 comment · 0 complexity · 5c67880485e1b62b260e615d46a181e7 MD5 · raw file

  1. /*=============================================================================
  2. Phoenix v1.2
  3. Copyright (c) 2001-2002 Joel de Guzman
  4. Distributed under the Boost Software License, Version 1.0. (See accompanying
  5. file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  6. ==============================================================================*/
  7. #ifndef PHOENIX_ACTOR_HPP
  8. #define PHOENIX_ACTOR_HPP
  9. ///////////////////////////////////////////////////////////////////////////////
  10. #include <boost/spirit/home/classic/phoenix/tuples.hpp>
  11. ///////////////////////////////////////////////////////////////////////////////
  12. namespace phoenix {
  13. // These are forward declared here because we cannot include impl.hpp
  14. // or operators.hpp yet but the actor's assignment operator and index
  15. // operator are required to be members.
  16. //////////////////////////////////
  17. struct assign_op;
  18. struct index_op;
  19. //////////////////////////////////
  20. namespace impl {
  21. template <typename OperationT, typename BaseT, typename B>
  22. struct make_binary1;
  23. }
  24. ///////////////////////////////////////////////////////////////////////////////
  25. //
  26. // unpack_tuple class
  27. //
  28. // This class is used to unpack a supplied tuple such, that the members of
  29. // this tuple will be handled as if they would be supplied separately.
  30. //
  31. ///////////////////////////////////////////////////////////////////////////////
  32. template <typename TupleT>
  33. struct unpack_tuple : public TupleT {
  34. typedef TupleT tuple_t;
  35. unpack_tuple() {}
  36. unpack_tuple(tuple_t const &tuple_) : TupleT(tuple_) {}
  37. };
  38. ///////////////////////////////////////////////////////////////////////////////
  39. //
  40. // actor class
  41. //
  42. // This class is a protocol class for all actors. This class is
  43. // essentially an interface contract. The actor class does not
  44. // really know how how to act on anything but instead relies on the
  45. // template parameter BaseT (from which the actor will derive from)
  46. // to do the actual action.
  47. //
  48. // An actor is a functor that is capable of accepting arguments up
  49. // to a predefined maximum. It is up to the base class to do the
  50. // actual processing or possibly to limit the arity (no. of
  51. // arguments) passed in. Upon invocation of the functor through a
  52. // supplied operator(), the actor funnels the arguments passed in
  53. // by the client into a tuple and calls the base eval member
  54. // function.
  55. //
  56. // Schematically:
  57. //
  58. // arg0 ---------|
  59. // arg1 ---------|
  60. // arg2 ---------|---> tupled_args ---> base.eval
  61. // ... |
  62. // argN ---------|
  63. //
  64. // actor::operator()(arg0, arg1... argN)
  65. // ---> BaseT::eval(tupled_args);
  66. //
  67. // Actor base classes from which this class inherits from are
  68. // expected to have a corresponding member function eval compatible
  69. // with the conceptual Interface:
  70. //
  71. // template <typename TupleT>
  72. // actor_return_type
  73. // eval(TupleT const& args) const;
  74. //
  75. // where args are the actual arguments passed in by the client
  76. // funneled into a tuple (see tuple.hpp for details).
  77. //
  78. // The actor_return_type can be anything. Base classes are free to
  79. // return any type, even argument dependent types (types that are
  80. // deduced from the types of the arguments). After evaluating the
  81. // parameters and doing some computations or actions, the eval
  82. // member function concludes by returning something back to the
  83. // client. To do this, the forwarding function (the actor's
  84. // operator()) needs to know the return type of the eval member
  85. // function that it is calling. For this purpose, actor base
  86. // classes are required to provide a nested template class:
  87. //
  88. // template <typename TupleT>
  89. // struct result;
  90. //
  91. // This auxiliary class provides the result type information
  92. // returned by the eval member function of a base actor class. The
  93. // nested template class result should have a typedef 'type' that
  94. // reflects the return type of its member function eval. It is
  95. // basically a type computer that answers the question "given
  96. // arguments packed into a TupleT type, what will be the result
  97. // type of the eval member function of ActorT?". The template class
  98. // actor_result queries this to extract the return type of an
  99. // actor. Example:
  100. //
  101. // typedef typename actor_result<ActorT, TupleT>::type
  102. // actor_return_type;
  103. //
  104. // where actor_return_type is the actual type returned by ActorT's
  105. // eval member function given some arguments in a TupleT.
  106. //
  107. ///////////////////////////////////////////////////////////////////////////////
  108. template <typename ActorT, typename TupleT>
  109. struct actor_result {
  110. typedef typename ActorT::template result<TupleT>::type type;
  111. typedef typename remove_reference<type>::type plain_type;
  112. };
  113. //////////////////////////////////
  114. #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
  115. #pragma warning(push)
  116. #pragma warning(disable:4512) //assignment operator could not be generated
  117. #endif
  118. template <typename BaseT>
  119. struct actor : public BaseT {
  120. actor();
  121. actor(BaseT const& base);
  122. typename actor_result<BaseT, tuple<> >::type
  123. operator()() const;
  124. template <typename A>
  125. typename actor_result<BaseT, tuple<A&> >::type
  126. operator()(A& a) const;
  127. template <typename A, typename B>
  128. typename actor_result<BaseT, tuple<A&, B&> >::type
  129. operator()(A& a, B& b) const;
  130. template <typename A, typename B, typename C>
  131. typename actor_result<BaseT, tuple<A&, B&, C&> >::type
  132. operator()(A& a, B& b, C& c) const;
  133. #if PHOENIX_LIMIT > 3
  134. template <typename A, typename B, typename C, typename D>
  135. typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
  136. operator()(A& a, B& b, C& c, D& d) const;
  137. template <typename A, typename B, typename C, typename D, typename E>
  138. typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
  139. operator()(A& a, B& b, C& c, D& d, E& e) const;
  140. template <
  141. typename A, typename B, typename C, typename D, typename E,
  142. typename F>
  143. typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&, F&> >::type
  144. operator()(A& a, B& b, C& c, D& d, E& e, F& f) const;
  145. #if PHOENIX_LIMIT > 6
  146. template <
  147. typename A, typename B, typename C, typename D, typename E,
  148. typename F, typename G>
  149. typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&, F&, G&> >::type
  150. operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g) const;
  151. template <
  152. typename A, typename B, typename C, typename D, typename E,
  153. typename F, typename G, typename H>
  154. typename actor_result<BaseT,
  155. tuple<A&, B&, C&, D&, E&, F&, G&, H&>
  156. >::type
  157. operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h) const;
  158. template <
  159. typename A, typename B, typename C, typename D, typename E,
  160. typename F, typename G, typename H, typename I>
  161. typename actor_result<BaseT,
  162. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
  163. >::type
  164. operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i) const;
  165. #if PHOENIX_LIMIT > 9
  166. template <
  167. typename A, typename B, typename C, typename D, typename E,
  168. typename F, typename G, typename H, typename I, typename J>
  169. typename actor_result<BaseT,
  170. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
  171. >::type
  172. operator()(
  173. A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j) const;
  174. template <
  175. typename A, typename B, typename C, typename D, typename E,
  176. typename F, typename G, typename H, typename I, typename J,
  177. typename K>
  178. typename actor_result<BaseT,
  179. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
  180. >::type
  181. operator()(
  182. A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
  183. K& k) const;
  184. template <
  185. typename A, typename B, typename C, typename D, typename E,
  186. typename F, typename G, typename H, typename I, typename J,
  187. typename K, typename L>
  188. typename actor_result<BaseT,
  189. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
  190. >::type
  191. operator()(
  192. A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
  193. K& k, L& l) const;
  194. #if PHOENIX_LIMIT > 12
  195. template <
  196. typename A, typename B, typename C, typename D, typename E,
  197. typename F, typename G, typename H, typename I, typename J,
  198. typename K, typename L, typename M>
  199. typename actor_result<BaseT,
  200. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
  201. >::type
  202. operator()(
  203. A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
  204. K& k, L& l, M& m) const;
  205. template <
  206. typename A, typename B, typename C, typename D, typename E,
  207. typename F, typename G, typename H, typename I, typename J,
  208. typename K, typename L, typename M, typename N>
  209. typename actor_result<BaseT,
  210. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
  211. >::type
  212. operator()(
  213. A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
  214. K& k, L& l, M& m, N& n) const;
  215. template <
  216. typename A, typename B, typename C, typename D, typename E,
  217. typename F, typename G, typename H, typename I, typename J,
  218. typename K, typename L, typename M, typename N, typename O>
  219. typename actor_result<BaseT,
  220. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
  221. >::type
  222. operator()(
  223. A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
  224. K& k, L& l, M& m, N& n, O& o) const;
  225. #endif
  226. #endif
  227. #endif
  228. #endif
  229. template <typename TupleT>
  230. typename actor_result<BaseT, unpack_tuple<TupleT> >::type
  231. operator()(unpack_tuple<TupleT> const &t) const;
  232. template <typename B>
  233. typename impl::make_binary1<assign_op, BaseT, B>::type
  234. operator=(B const& b) const;
  235. template <typename B>
  236. typename impl::make_binary1<index_op, BaseT, B>::type
  237. operator[](B const& b) const;
  238. };
  239. #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
  240. #pragma warning(pop)
  241. #endif
  242. ///////////////////////////////////////////////////////////////////////////
  243. //
  244. // as_actor
  245. //
  246. // as_actor is a meta-program that converts an arbitrary type into
  247. // an actor. All participants in the framework must be first-class
  248. // actors. This meta-program is used all throughout the framework
  249. // whenever an unknown type needs to be converted to an actor.
  250. // as_actor specializations are expected to have a typedef 'type'.
  251. // This is the destination actor type. A static member function
  252. // 'convert' converts an object to this target type.
  253. //
  254. // The meta-program does no conversion if the object to be
  255. // converted is already an actor.
  256. //
  257. ///////////////////////////////////////////////////////////////////////////
  258. template <typename T>
  259. struct as_actor;
  260. //////////////////////////////////
  261. template <typename BaseT>
  262. struct as_actor<actor<BaseT> > {
  263. typedef actor<BaseT> type;
  264. static type convert(actor<BaseT> const& x) { return x; }
  265. };
  266. //////////////////////////////////
  267. template <>
  268. struct as_actor<nil_t> {
  269. typedef nil_t type;
  270. static nil_t convert(nil_t /*x*/)
  271. { return nil_t(); }
  272. };
  273. //////////////////////////////////
  274. template <>
  275. struct as_actor<void> {
  276. typedef void type;
  277. // ERROR!!!
  278. };
  279. ///////////////////////////////////////////////////////////////////////////////
  280. //
  281. // actor class implementation
  282. //
  283. ///////////////////////////////////////////////////////////////////////////////
  284. template <typename BaseT>
  285. actor<BaseT>::actor()
  286. : BaseT() {}
  287. //////////////////////////////////
  288. template <typename BaseT>
  289. actor<BaseT>::actor(BaseT const& base)
  290. : BaseT(base) {}
  291. //////////////////////////////////
  292. template <typename BaseT>
  293. inline typename actor_result<BaseT, tuple<> >::type
  294. actor<BaseT>::operator()() const
  295. {
  296. return BaseT::eval(tuple<>());
  297. }
  298. //////////////////////////////////
  299. template <typename BaseT>
  300. template <typename A>
  301. inline typename actor_result<BaseT, tuple<A&> >::type
  302. actor<BaseT>::operator()(A& a_) const
  303. {
  304. return BaseT::eval(tuple<A&>(a_));
  305. }
  306. //////////////////////////////////
  307. template <typename BaseT>
  308. template <typename A, typename B>
  309. inline typename actor_result<BaseT, tuple<A&, B&> >::type
  310. actor<BaseT>::operator()(A& a_, B& b_) const
  311. {
  312. return BaseT::eval(tuple<A&, B&>(a_, b_));
  313. }
  314. //////////////////////////////////
  315. template <typename BaseT>
  316. template <typename A, typename B, typename C>
  317. inline typename actor_result<BaseT, tuple<A&, B&, C&> >::type
  318. actor<BaseT>::operator()(A& a_, B& b_, C& c_) const
  319. {
  320. return BaseT::eval(tuple<A&, B&, C&>(a_, b_, c_));
  321. }
  322. #if PHOENIX_LIMIT > 3
  323. //////////////////////////////////
  324. template <typename BaseT>
  325. template <typename A, typename B, typename C, typename D>
  326. inline typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
  327. actor<BaseT>::operator()(A& a_, B& b_, C& c_, D& d_) const
  328. {
  329. return BaseT::eval(tuple<A&, B&, C&, D&>(a_, b_, c_, d_));
  330. }
  331. //////////////////////////////////
  332. template <typename BaseT>
  333. template <typename A, typename B, typename C, typename D, typename E>
  334. inline typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
  335. actor<BaseT>::operator()(A& a_, B& b_, C& c_, D& d_, E& e_) const
  336. {
  337. return BaseT::eval(tuple<A&, B&, C&, D&, E&>(a_, b_, c_, d_, e_));
  338. }
  339. //////////////////////////////////
  340. template <typename BaseT>
  341. template <
  342. typename A, typename B, typename C, typename D, typename E,
  343. typename F>
  344. inline typename actor_result<BaseT,
  345. tuple<A&, B&, C&, D&, E&, F&>
  346. >::type
  347. actor<BaseT>::operator()(
  348. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_
  349. ) const
  350. {
  351. return BaseT::eval(
  352. tuple<A&, B&, C&, D&, E&, F&>
  353. (a_, b_, c_, d_, e_, f_)
  354. );
  355. }
  356. #if PHOENIX_LIMIT > 6
  357. //////////////////////////////////
  358. template <typename BaseT>
  359. template <
  360. typename A, typename B, typename C, typename D, typename E,
  361. typename F, typename G>
  362. inline typename actor_result<BaseT,
  363. tuple<A&, B&, C&, D&, E&, F&, G&>
  364. >::type
  365. actor<BaseT>::operator()(
  366. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_
  367. ) const
  368. {
  369. return BaseT::eval(
  370. tuple<A&, B&, C&, D&, E&, F&, G&>
  371. (a_, b_, c_, d_, e_, f_, g_)
  372. );
  373. }
  374. //////////////////////////////////
  375. template <typename BaseT>
  376. template <
  377. typename A, typename B, typename C, typename D, typename E,
  378. typename F, typename G, typename H>
  379. inline typename actor_result<BaseT,
  380. tuple<A&, B&, C&, D&, E&, F&, G&, H&>
  381. >::type
  382. actor<BaseT>::operator()(
  383. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_
  384. ) const
  385. {
  386. return BaseT::eval(
  387. tuple<A&, B&, C&, D&, E&, F&, G&, H&>
  388. (a_, b_, c_, d_, e_, f_, g_, h_)
  389. );
  390. }
  391. //////////////////////////////////
  392. template <typename BaseT>
  393. template <
  394. typename A, typename B, typename C, typename D, typename E,
  395. typename F, typename G, typename H, typename I>
  396. inline typename actor_result<BaseT,
  397. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
  398. >::type
  399. actor<BaseT>::operator()(
  400. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_
  401. ) const
  402. {
  403. return BaseT::eval(
  404. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
  405. (a_, b_, c_, d_, e_, f_, g_, h_, i_)
  406. );
  407. }
  408. #if PHOENIX_LIMIT > 9
  409. //////////////////////////////////
  410. template <typename BaseT>
  411. template <
  412. typename A, typename B, typename C, typename D, typename E,
  413. typename F, typename G, typename H, typename I, typename J>
  414. inline typename actor_result<BaseT,
  415. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
  416. >::type
  417. actor<BaseT>::operator()(
  418. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_
  419. ) const
  420. {
  421. return BaseT::eval(
  422. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
  423. (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_)
  424. );
  425. }
  426. //////////////////////////////////
  427. template <typename BaseT>
  428. template <
  429. typename A, typename B, typename C, typename D, typename E,
  430. typename F, typename G, typename H, typename I, typename J,
  431. typename K>
  432. inline typename actor_result<BaseT,
  433. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
  434. >::type
  435. actor<BaseT>::operator()(
  436. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
  437. K& k_
  438. ) const
  439. {
  440. return BaseT::eval(
  441. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
  442. (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_)
  443. );
  444. }
  445. //////////////////////////////////
  446. template <typename BaseT>
  447. template <
  448. typename A, typename B, typename C, typename D, typename E,
  449. typename F, typename G, typename H, typename I, typename J,
  450. typename K, typename L>
  451. inline typename actor_result<BaseT,
  452. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
  453. >::type
  454. actor<BaseT>::operator()(
  455. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
  456. K& k_, L& l_
  457. ) const
  458. {
  459. return BaseT::eval(
  460. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
  461. (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_)
  462. );
  463. }
  464. #if PHOENIX_LIMIT > 12
  465. //////////////////////////////////
  466. template <typename BaseT>
  467. template <
  468. typename A, typename B, typename C, typename D, typename E,
  469. typename F, typename G, typename H, typename I, typename J,
  470. typename K, typename L, typename M>
  471. inline typename actor_result<BaseT,
  472. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
  473. >::type
  474. actor<BaseT>::operator()(
  475. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
  476. K& k_, L& l_, M& m_
  477. ) const
  478. {
  479. return BaseT::eval(
  480. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
  481. (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_, m_)
  482. );
  483. }
  484. //////////////////////////////////
  485. template <typename BaseT>
  486. template <
  487. typename A, typename B, typename C, typename D, typename E,
  488. typename F, typename G, typename H, typename I, typename J,
  489. typename K, typename L, typename M, typename N>
  490. inline typename actor_result<BaseT,
  491. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
  492. >::type
  493. actor<BaseT>::operator()(
  494. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
  495. K& k_, L& l_, M& m_, N& n_
  496. ) const
  497. {
  498. return BaseT::eval(
  499. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
  500. (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_, m_, n_)
  501. );
  502. }
  503. //////////////////////////////////
  504. template <typename BaseT>
  505. template <
  506. typename A, typename B, typename C, typename D, typename E,
  507. typename F, typename G, typename H, typename I, typename J,
  508. typename K, typename L, typename M, typename N, typename O>
  509. inline typename actor_result<BaseT,
  510. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
  511. >::type
  512. actor<BaseT>::operator()(
  513. A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
  514. K& k_, L& l_, M& m_, N& n_, O& o_
  515. ) const
  516. {
  517. return BaseT::eval(
  518. tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
  519. (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_, m_, n_, o_)
  520. );
  521. }
  522. #endif
  523. #endif
  524. #endif
  525. #endif
  526. //////////////////////////////////
  527. template <typename BaseT>
  528. template <typename TupleT>
  529. typename actor_result<BaseT, unpack_tuple<TupleT> >::type
  530. actor<BaseT>::operator()(unpack_tuple<TupleT> const &t) const
  531. {
  532. return BaseT::eval(t);
  533. }
  534. ///////////////////////////////////////////////////////////////////////////////
  535. } // namespace phoenix
  536. #endif