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