]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*============================================================================= |
2 | Phoenix V1.2.1 | |
3 | Copyright (c) 2002 Joel de Guzman | |
4 | Copyright (c) 2002-2003 Hartmut Kaiser | |
5 | ||
6 | Distributed under the Boost Software License, Version 1.0. (See accompanying | |
7 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
8 | ==============================================================================*/ | |
9 | #ifndef PHOENIX_TUPLEHELPERS_HPP | |
10 | #define PHOENIX_TUPLEHELPERS_HPP | |
11 | ||
12 | /////////////////////////////////////////////////////////////////////////////// | |
13 | #include <cassert> | |
14 | #include <boost/spirit/home/classic/phoenix/tuples.hpp> | |
15 | ||
16 | /////////////////////////////////////////////////////////////////////////////// | |
17 | namespace phoenix | |
18 | { | |
19 | ||
20 | /////////////////////////////////////////////////////////////////////////////// | |
21 | // | |
22 | // make_tuple template class | |
23 | // | |
24 | // This template class is used to calculate a tuple type required to hold | |
25 | // the given template parameter type | |
26 | // | |
27 | /////////////////////////////////////////////////////////////////////////////// | |
28 | ||
29 | /////////////////////////////////////////////////////////////////////////////// | |
30 | // normal (non-tuple types are wrapped into a tuple) | |
31 | template <typename ResultT> | |
32 | struct make_tuple { | |
33 | ||
34 | typedef tuple<ResultT> type; | |
35 | }; | |
36 | ||
37 | /////////////////////////////////////////////////////////////////////////////// | |
38 | // nil_t is converted to an empty tuple type | |
39 | template <> | |
40 | struct make_tuple<nil_t> { | |
41 | ||
42 | typedef tuple<> type; | |
43 | }; | |
44 | ||
45 | /////////////////////////////////////////////////////////////////////////////// | |
46 | // tuple types are left alone without any refactoring | |
47 | template < | |
48 | typename A, typename B, typename C | |
49 | #if PHOENIX_LIMIT > 3 | |
50 | , typename D, typename E, typename F | |
51 | #if PHOENIX_LIMIT > 6 | |
52 | , typename G, typename H, typename I | |
53 | #if PHOENIX_LIMIT > 9 | |
54 | , typename J, typename K, typename L | |
55 | #if PHOENIX_LIMIT > 12 | |
56 | , typename M, typename N, typename O | |
57 | #endif | |
58 | #endif | |
59 | #endif | |
60 | #endif | |
61 | > | |
62 | struct make_tuple<tuple<A, B, C | |
63 | #if PHOENIX_LIMIT > 3 | |
64 | , D, E, F | |
65 | #if PHOENIX_LIMIT > 6 | |
66 | , G, H, I | |
67 | #if PHOENIX_LIMIT > 9 | |
68 | , J, K, L | |
69 | #if PHOENIX_LIMIT > 12 | |
70 | , M, N, O | |
71 | #endif | |
72 | #endif | |
73 | #endif | |
74 | #endif | |
75 | > > { | |
76 | ||
77 | // the tuple parameter itself is the required tuple type | |
78 | typedef tuple<A, B, C | |
79 | #if PHOENIX_LIMIT > 3 | |
80 | , D, E, F | |
81 | #if PHOENIX_LIMIT > 6 | |
82 | , G, H, I | |
83 | #if PHOENIX_LIMIT > 9 | |
84 | , J, K, L | |
85 | #if PHOENIX_LIMIT > 12 | |
86 | , M, N, O | |
87 | #endif | |
88 | #endif | |
89 | #endif | |
90 | #endif | |
91 | > type; | |
92 | }; | |
93 | ||
94 | /////////////////////////////////////////////////////////////////////////////// | |
95 | // | |
96 | // concat_tuple type computer | |
97 | // | |
98 | // This class returns the type of a tuple, which is constructed by | |
99 | // concatenating a tuple with a given type | |
100 | // | |
101 | /////////////////////////////////////////////////////////////////////////////// | |
102 | template <typename TupleT, typename AppendT> | |
103 | struct concat_tuple; | |
104 | ||
105 | /////////////////////////////////////////////////////////////////////////////// | |
106 | // | |
107 | // concat tuple <0 member> class | |
108 | // | |
109 | /////////////////////////////////////////////////////////////////////////////// | |
110 | template <typename AppendT> | |
111 | struct concat_tuple<tuple<>, AppendT> { | |
112 | ||
113 | typedef tuple<AppendT> type; | |
114 | }; | |
115 | ||
116 | template <> | |
117 | struct concat_tuple<tuple<>, nil_t> { | |
118 | ||
119 | typedef tuple<> type; | |
120 | }; | |
121 | ||
122 | /////////////////////////////////////////////////////////////////////////////// | |
123 | // | |
124 | // concat tuple <1 member> class | |
125 | // | |
126 | /////////////////////////////////////////////////////////////////////////////// | |
127 | template <typename A, typename AppendT> | |
128 | struct concat_tuple<tuple<A>, AppendT> { | |
129 | ||
130 | typedef tuple<A, AppendT> type; | |
131 | }; | |
132 | ||
133 | template <typename A> | |
134 | struct concat_tuple<tuple<A>, nil_t> { | |
135 | ||
136 | typedef tuple<A> type; | |
137 | }; | |
138 | ||
139 | /////////////////////////////////////////////////////////////////////////////// | |
140 | // | |
141 | // concat tuple <2 member> class | |
142 | // | |
143 | /////////////////////////////////////////////////////////////////////////////// | |
144 | template <typename A, typename B, typename AppendT> | |
145 | struct concat_tuple<tuple<A, B>, AppendT> { | |
146 | ||
147 | typedef tuple<A, B, AppendT> type; | |
148 | }; | |
149 | ||
150 | template <typename A, typename B> | |
151 | struct concat_tuple<tuple<A, B>, nil_t> { | |
152 | ||
153 | typedef tuple<A, B> type; | |
154 | }; | |
155 | ||
156 | #if PHOENIX_LIMIT > 3 | |
157 | /////////////////////////////////////////////////////////////////////////////// | |
158 | // | |
159 | // concat tuple <3 member> class | |
160 | // | |
161 | /////////////////////////////////////////////////////////////////////////////// | |
162 | template < | |
163 | typename A, typename B, typename C, | |
164 | typename AppendT | |
165 | > | |
166 | struct concat_tuple<tuple<A, B, C>, AppendT> { | |
167 | ||
168 | typedef tuple<A, B, C, AppendT> type; | |
169 | }; | |
170 | ||
171 | template < | |
172 | typename A, typename B, typename C | |
173 | > | |
174 | struct concat_tuple<tuple<A, B, C>, nil_t> { | |
175 | ||
176 | typedef tuple<A, B, C> type; | |
177 | }; | |
178 | ||
179 | /////////////////////////////////////////////////////////////////////////////// | |
180 | // | |
181 | // concat tuple <4 member> class | |
182 | // | |
183 | /////////////////////////////////////////////////////////////////////////////// | |
184 | template < | |
185 | typename A, typename B, typename C, typename D, | |
186 | typename AppendT | |
187 | > | |
188 | struct concat_tuple<tuple<A, B, C, D>, AppendT> { | |
189 | ||
190 | typedef tuple<A, B, C, D, AppendT> type; | |
191 | }; | |
192 | ||
193 | template < | |
194 | typename A, typename B, typename C, typename D | |
195 | > | |
196 | struct concat_tuple<tuple<A, B, C, D>, nil_t> { | |
197 | ||
198 | typedef tuple<A, B, C, D> type; | |
199 | }; | |
200 | ||
201 | /////////////////////////////////////////////////////////////////////////////// | |
202 | // | |
203 | // concat tuple <5 member> class | |
204 | // | |
205 | /////////////////////////////////////////////////////////////////////////////// | |
206 | template < | |
207 | typename A, typename B, typename C, typename D, typename E, | |
208 | typename AppendT | |
209 | > | |
210 | struct concat_tuple<tuple<A, B, C, D, E>, AppendT> { | |
211 | ||
212 | typedef tuple<A, B, C, D, E, AppendT> type; | |
213 | }; | |
214 | ||
215 | template < | |
216 | typename A, typename B, typename C, typename D, typename E | |
217 | > | |
218 | struct concat_tuple<tuple<A, B, C, D, E>, nil_t> { | |
219 | ||
220 | typedef tuple<A, B, C, D, E> type; | |
221 | }; | |
222 | ||
223 | #if PHOENIX_LIMIT > 6 | |
224 | /////////////////////////////////////////////////////////////////////////////// | |
225 | // | |
226 | // concat tuple <6 member> class | |
227 | // | |
228 | /////////////////////////////////////////////////////////////////////////////// | |
229 | template < | |
230 | typename A, typename B, typename C, typename D, typename E, typename F, | |
231 | typename AppendT | |
232 | > | |
233 | struct concat_tuple<tuple<A, B, C, D, E, F>, AppendT> { | |
234 | ||
235 | typedef tuple<A, B, C, D, E, F, AppendT> type; | |
236 | }; | |
237 | ||
238 | template < | |
239 | typename A, typename B, typename C, typename D, typename E, typename F | |
240 | > | |
241 | struct concat_tuple<tuple<A, B, C, D, E, F>, nil_t> { | |
242 | ||
243 | typedef tuple<A, B, C, D, E, F> type; | |
244 | }; | |
245 | ||
246 | /////////////////////////////////////////////////////////////////////////////// | |
247 | // | |
248 | // concat tuple <7 member> class | |
249 | // | |
250 | /////////////////////////////////////////////////////////////////////////////// | |
251 | template < | |
252 | typename A, typename B, typename C, typename D, typename E, typename F, | |
253 | typename G, | |
254 | typename AppendT | |
255 | > | |
256 | struct concat_tuple<tuple<A, B, C, D, E, F, G>, AppendT> { | |
257 | ||
258 | typedef tuple<A, B, C, D, E, F, G, AppendT> type; | |
259 | }; | |
260 | ||
261 | template < | |
262 | typename A, typename B, typename C, typename D, typename E, typename F, | |
263 | typename G | |
264 | > | |
265 | struct concat_tuple<tuple<A, B, C, D, E, F, G>, nil_t> { | |
266 | ||
267 | typedef tuple<A, B, C, D, E, F, G> type; | |
268 | }; | |
269 | ||
270 | /////////////////////////////////////////////////////////////////////////////// | |
271 | // | |
272 | // concat tuple <8 member> class | |
273 | // | |
274 | /////////////////////////////////////////////////////////////////////////////// | |
275 | template < | |
276 | typename A, typename B, typename C, typename D, typename E, typename F, | |
277 | typename G, typename H, | |
278 | typename AppendT | |
279 | > | |
280 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H>, AppendT> { | |
281 | ||
282 | typedef tuple<A, B, C, D, E, F, G, H, AppendT> type; | |
283 | }; | |
284 | ||
285 | template < | |
286 | typename A, typename B, typename C, typename D, typename E, typename F, | |
287 | typename G, typename H | |
288 | > | |
289 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H>, nil_t> { | |
290 | ||
291 | typedef tuple<A, B, C, D, E, F, G, H> type; | |
292 | }; | |
293 | ||
294 | #if PHOENIX_LIMIT > 9 | |
295 | /////////////////////////////////////////////////////////////////////////////// | |
296 | // | |
297 | // concat tuple <9 member> class | |
298 | // | |
299 | /////////////////////////////////////////////////////////////////////////////// | |
300 | template < | |
301 | typename A, typename B, typename C, typename D, typename E, typename F, | |
302 | typename G, typename H, typename I, | |
303 | typename AppendT | |
304 | > | |
305 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I>, AppendT> { | |
306 | ||
307 | typedef tuple<A, B, C, D, E, F, G, H, I, AppendT> type; | |
308 | }; | |
309 | ||
310 | template < | |
311 | typename A, typename B, typename C, typename D, typename E, typename F, | |
312 | typename G, typename H, typename I | |
313 | > | |
314 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I>, nil_t> { | |
315 | ||
316 | typedef tuple<A, B, C, D, E, F, G, H, I> type; | |
317 | }; | |
318 | ||
319 | /////////////////////////////////////////////////////////////////////////////// | |
320 | // | |
321 | // concat tuple <10 member> class | |
322 | // | |
323 | /////////////////////////////////////////////////////////////////////////////// | |
324 | template < | |
325 | typename A, typename B, typename C, typename D, typename E, typename F, | |
326 | typename G, typename H, typename I, typename J, | |
327 | typename AppendT | |
328 | > | |
329 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J>, AppendT> { | |
330 | ||
331 | typedef tuple<A, B, C, D, E, F, G, H, I, J, AppendT> type; | |
332 | }; | |
333 | ||
334 | template < | |
335 | typename A, typename B, typename C, typename D, typename E, typename F, | |
336 | typename G, typename H, typename I, typename J | |
337 | > | |
338 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J>, nil_t> { | |
339 | ||
340 | typedef tuple<A, B, C, D, E, F, G, H, I, J> type; | |
341 | }; | |
342 | ||
343 | /////////////////////////////////////////////////////////////////////////////// | |
344 | // | |
345 | // concat tuple <11 member> class | |
346 | // | |
347 | /////////////////////////////////////////////////////////////////////////////// | |
348 | template < | |
349 | typename A, typename B, typename C, typename D, typename E, typename F, | |
350 | typename G, typename H, typename I, typename J, typename K, | |
351 | typename AppendT | |
352 | > | |
353 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K>, AppendT> { | |
354 | ||
355 | typedef tuple<A, B, C, D, E, F, G, H, I, J, K, AppendT> type; | |
356 | }; | |
357 | ||
358 | template < | |
359 | typename A, typename B, typename C, typename D, typename E, typename F, | |
360 | typename G, typename H, typename I, typename J, typename K | |
361 | > | |
362 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K>, nil_t> { | |
363 | ||
364 | typedef tuple<A, B, C, D, E, F, G, H, I, J, K> type; | |
365 | }; | |
366 | ||
367 | #if PHOENIX_LIMIT > 12 | |
368 | /////////////////////////////////////////////////////////////////////////////// | |
369 | // | |
370 | // concat tuple <12 member> class | |
371 | // | |
372 | /////////////////////////////////////////////////////////////////////////////// | |
373 | template < | |
374 | typename A, typename B, typename C, typename D, typename E, typename F, | |
375 | typename G, typename H, typename I, typename J, typename K, typename L, | |
376 | typename AppendT | |
377 | > | |
378 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L>, AppendT> { | |
379 | ||
380 | typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, AppendT> type; | |
381 | }; | |
382 | ||
383 | template < | |
384 | typename A, typename B, typename C, typename D, typename E, typename F, | |
385 | typename G, typename H, typename I, typename J, typename K, typename L | |
386 | > | |
387 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L>, nil_t> { | |
388 | ||
389 | typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L> type; | |
390 | }; | |
391 | ||
392 | /////////////////////////////////////////////////////////////////////////////// | |
393 | // | |
394 | // concat tuple <13 member> class | |
395 | // | |
396 | /////////////////////////////////////////////////////////////////////////////// | |
397 | template < | |
398 | typename A, typename B, typename C, typename D, typename E, typename F, | |
399 | typename G, typename H, typename I, typename J, typename K, typename L, | |
400 | typename M, | |
401 | typename AppendT | |
402 | > | |
403 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M>, AppendT> { | |
404 | ||
405 | typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, AppendT> type; | |
406 | }; | |
407 | ||
408 | template < | |
409 | typename A, typename B, typename C, typename D, typename E, typename F, | |
410 | typename G, typename H, typename I, typename J, typename K, typename L, | |
411 | typename M | |
412 | > | |
413 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M>, nil_t> { | |
414 | ||
415 | typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M> type; | |
416 | }; | |
417 | ||
418 | /////////////////////////////////////////////////////////////////////////////// | |
419 | // | |
420 | // concat tuple <14 member> class | |
421 | // | |
422 | /////////////////////////////////////////////////////////////////////////////// | |
423 | template < | |
424 | typename A, typename B, typename C, typename D, typename E, typename F, | |
425 | typename G, typename H, typename I, typename J, typename K, typename L, | |
426 | typename M, typename N, | |
427 | typename AppendT | |
428 | > | |
429 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, AppendT> { | |
430 | ||
431 | typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, AppendT> type; | |
432 | }; | |
433 | ||
434 | template < | |
435 | typename A, typename B, typename C, typename D, typename E, typename F, | |
436 | typename G, typename H, typename I, typename J, typename K, typename L, | |
437 | typename M, typename N | |
438 | > | |
439 | struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, nil_t> { | |
440 | ||
441 | typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N> type; | |
442 | }; | |
443 | ||
444 | #endif | |
445 | #endif | |
446 | #endif | |
447 | #endif | |
448 | ||
449 | /////////////////////////////////////////////////////////////////////////////// | |
450 | // | |
451 | // concat_tuples type computer | |
452 | // | |
453 | // This template class returns the type of a tuple built from the | |
454 | // concatenation of two given tuples. | |
455 | // | |
456 | /////////////////////////////////////////////////////////////////////////////// | |
457 | template <typename TupleT1, typename TupleT2, int N, typename AppendT> | |
458 | struct concat_tuple_element { | |
459 | ||
460 | typedef | |
461 | typename concat_tuple_element< | |
462 | typename concat_tuple<TupleT1, AppendT>::type, TupleT2, N+1, | |
463 | typename tuple_element<N+1, TupleT2>::type | |
464 | >::type | |
465 | type; | |
466 | }; | |
467 | ||
468 | template <typename TupleT1, typename TupleT2, int N> | |
469 | struct concat_tuple_element<TupleT1, TupleT2, N, nil_t> { | |
470 | ||
471 | typedef TupleT1 type; | |
472 | }; | |
473 | ||
474 | template <typename TupleT1, typename TupleT2> | |
475 | struct concat_tuples { | |
476 | ||
477 | typedef | |
478 | typename concat_tuple_element< | |
479 | TupleT1, TupleT2, 0, | |
480 | typename tuple_element<0, TupleT2>::type | |
481 | >::type | |
482 | type; | |
483 | }; | |
484 | ||
485 | /////////////////////////////////////////////////////////////////////////////// | |
486 | // | |
487 | // convert_actors template function | |
488 | // | |
489 | // The convert_actors template functions constructs a new tuple object | |
490 | // composed of the elements returned by the actors contained in the | |
491 | // input tuple. (i.e. the given tuple type 'actor_tuple' contains a set | |
492 | // of actors to evaluate and the resulting tuple contains the results of | |
493 | // evaluating the actors.) | |
494 | // | |
495 | /////////////////////////////////////////////////////////////////////////////// | |
496 | template <typename ActorT, typename TupleT> | |
497 | struct actor_result; // forward declaration | |
498 | ||
499 | namespace impl | |
500 | { | |
501 | template <unsigned N> | |
502 | struct convert_actors_ {}; | |
503 | } | |
504 | ||
505 | template <typename TupleResultT, typename ActorTupleT> | |
506 | TupleResultT | |
507 | convert_actors(ActorTupleT const& actor_tuple) | |
508 | { | |
509 | BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length); | |
510 | BOOST_STATIC_CONSTANT(int, length = TupleResultT::length); | |
511 | return impl::convert_actors_<length> | |
512 | ::template apply<TupleResultT, ActorTupleT>::do_(actor_tuple); | |
513 | } | |
514 | ||
515 | namespace impl | |
516 | { | |
517 | template <int N, typename TupleResultT, typename ActorTupleT> | |
518 | struct convert_actor | |
519 | { | |
520 | typedef typename tuple_element<N, TupleResultT>::type type; | |
521 | ||
522 | template <bool C> | |
523 | struct is_default_t {}; | |
524 | typedef is_default_t<true> is_default; | |
525 | typedef is_default_t<false> is_not_default; | |
526 | ||
527 | static type | |
528 | actor_element(ActorTupleT const& /*actor_tuple*/, is_default) | |
529 | { | |
530 | return type(); // default construct | |
531 | } | |
532 | ||
533 | static type | |
534 | actor_element(ActorTupleT const& actor_tuple, is_not_default) | |
535 | { | |
536 | BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length); | |
537 | return actor_tuple[tuple_index<N>()](); // apply the actor | |
538 | } | |
539 | ||
540 | static type | |
541 | do_(ActorTupleT const& actor_tuple) | |
542 | { | |
543 | return actor_element( | |
544 | actor_tuple, is_default_t<(N >= ActorTupleT::length)>()); | |
545 | } | |
546 | }; | |
547 | ||
548 | /////////////////////////////////////// | |
549 | template <> | |
550 | struct convert_actors_<1> | |
551 | { | |
552 | template <typename TupleResultT, typename ActorTupleT> | |
553 | struct apply | |
554 | { | |
555 | static TupleResultT | |
556 | do_(ActorTupleT const& actor_tuple) | |
557 | { | |
558 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
559 | ||
560 | return TupleResultT( | |
561 | converter0::do_(actor_tuple) | |
562 | ); | |
563 | } | |
564 | }; | |
565 | }; | |
566 | ||
567 | /////////////////////////////////////// | |
568 | template <> | |
569 | struct convert_actors_<2> | |
570 | { | |
571 | template <typename TupleResultT, typename ActorTupleT> | |
572 | struct apply | |
573 | { | |
574 | static TupleResultT | |
575 | do_(ActorTupleT const& actor_tuple) | |
576 | { | |
577 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
578 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
579 | ||
580 | using namespace tuple_index_names; | |
581 | return TupleResultT( | |
582 | converter0::do_(actor_tuple) | |
583 | , converter1::do_(actor_tuple) | |
584 | ); | |
585 | } | |
586 | }; | |
587 | }; | |
588 | ||
589 | /////////////////////////////////////// | |
590 | template <> | |
591 | struct convert_actors_<3> | |
592 | { | |
593 | template <typename TupleResultT, typename ActorTupleT> | |
594 | struct apply | |
595 | { | |
596 | static TupleResultT | |
597 | do_(ActorTupleT const& actor_tuple) | |
598 | { | |
599 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
600 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
601 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
602 | ||
603 | using namespace tuple_index_names; | |
604 | return TupleResultT( | |
605 | converter0::do_(actor_tuple) | |
606 | , converter1::do_(actor_tuple) | |
607 | , converter2::do_(actor_tuple) | |
608 | ); | |
609 | } | |
610 | }; | |
611 | }; | |
612 | ||
613 | #if PHOENIX_LIMIT > 3 | |
614 | ||
615 | ///////////////////////////////////// | |
616 | template <> | |
617 | struct convert_actors_<4> | |
618 | { | |
619 | template <typename TupleResultT, typename ActorTupleT> | |
620 | struct apply | |
621 | { | |
622 | static TupleResultT | |
623 | do_(ActorTupleT const& actor_tuple) | |
624 | { | |
625 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
626 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
627 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
628 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
629 | ||
630 | using namespace tuple_index_names; | |
631 | return TupleResultT( | |
632 | converter0::do_(actor_tuple) | |
633 | , converter1::do_(actor_tuple) | |
634 | , converter2::do_(actor_tuple) | |
635 | , converter3::do_(actor_tuple) | |
636 | ); | |
637 | } | |
638 | }; | |
639 | }; | |
640 | ||
641 | ///////////////////////////////////// | |
642 | template <> | |
643 | struct convert_actors_<5> | |
644 | { | |
645 | template <typename TupleResultT, typename ActorTupleT> | |
646 | struct apply | |
647 | { | |
648 | static TupleResultT | |
649 | do_(ActorTupleT const& actor_tuple) | |
650 | { | |
651 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
652 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
653 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
654 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
655 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
656 | ||
657 | using namespace tuple_index_names; | |
658 | return TupleResultT( | |
659 | converter0::do_(actor_tuple) | |
660 | , converter1::do_(actor_tuple) | |
661 | , converter2::do_(actor_tuple) | |
662 | , converter3::do_(actor_tuple) | |
663 | , converter4::do_(actor_tuple) | |
664 | ); | |
665 | } | |
666 | }; | |
667 | }; | |
668 | ||
669 | ///////////////////////////////////// | |
670 | template <> | |
671 | struct convert_actors_<6> | |
672 | { | |
673 | template <typename TupleResultT, typename ActorTupleT> | |
674 | struct apply | |
675 | { | |
676 | static TupleResultT | |
677 | do_(ActorTupleT const& actor_tuple) | |
678 | { | |
679 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
680 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
681 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
682 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
683 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
684 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
685 | ||
686 | using namespace tuple_index_names; | |
687 | return TupleResultT( | |
688 | converter0::do_(actor_tuple) | |
689 | , converter1::do_(actor_tuple) | |
690 | , converter2::do_(actor_tuple) | |
691 | , converter3::do_(actor_tuple) | |
692 | , converter4::do_(actor_tuple) | |
693 | , converter5::do_(actor_tuple) | |
694 | ); | |
695 | } | |
696 | }; | |
697 | }; | |
698 | ||
699 | #if PHOENIX_LIMIT > 6 | |
700 | ||
701 | ///////////////////////////////////// | |
702 | template <> | |
703 | struct convert_actors_<7> | |
704 | { | |
705 | template <typename TupleResultT, typename ActorTupleT> | |
706 | struct apply | |
707 | { | |
708 | static TupleResultT | |
709 | do_(ActorTupleT const& actor_tuple) | |
710 | { | |
711 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
712 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
713 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
714 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
715 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
716 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
717 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
718 | ||
719 | using namespace tuple_index_names; | |
720 | return TupleResultT( | |
721 | converter0::do_(actor_tuple) | |
722 | , converter1::do_(actor_tuple) | |
723 | , converter2::do_(actor_tuple) | |
724 | , converter3::do_(actor_tuple) | |
725 | , converter4::do_(actor_tuple) | |
726 | , converter5::do_(actor_tuple) | |
727 | , converter6::do_(actor_tuple) | |
728 | ); | |
729 | } | |
730 | }; | |
731 | }; | |
732 | ||
733 | ///////////////////////////////////// | |
734 | template <> | |
735 | struct convert_actors_<8> | |
736 | { | |
737 | template <typename TupleResultT, typename ActorTupleT> | |
738 | struct apply | |
739 | { | |
740 | static TupleResultT | |
741 | do_(ActorTupleT const& actor_tuple) | |
742 | { | |
743 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
744 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
745 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
746 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
747 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
748 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
749 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
750 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
751 | ||
752 | using namespace tuple_index_names; | |
753 | return TupleResultT( | |
754 | converter0::do_(actor_tuple) | |
755 | , converter1::do_(actor_tuple) | |
756 | , converter2::do_(actor_tuple) | |
757 | , converter3::do_(actor_tuple) | |
758 | , converter4::do_(actor_tuple) | |
759 | , converter5::do_(actor_tuple) | |
760 | , converter6::do_(actor_tuple) | |
761 | , converter7::do_(actor_tuple) | |
762 | ); | |
763 | } | |
764 | }; | |
765 | }; | |
766 | ||
767 | ///////////////////////////////////// | |
768 | template <> | |
769 | struct convert_actors_<9> | |
770 | { | |
771 | template <typename TupleResultT, typename ActorTupleT> | |
772 | struct apply | |
773 | { | |
774 | static TupleResultT | |
775 | do_(ActorTupleT const& actor_tuple) | |
776 | { | |
777 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
778 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
779 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
780 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
781 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
782 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
783 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
784 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
785 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
786 | ||
787 | using namespace tuple_index_names; | |
788 | return TupleResultT( | |
789 | converter0::do_(actor_tuple) | |
790 | , converter1::do_(actor_tuple) | |
791 | , converter2::do_(actor_tuple) | |
792 | , converter3::do_(actor_tuple) | |
793 | , converter4::do_(actor_tuple) | |
794 | , converter5::do_(actor_tuple) | |
795 | , converter6::do_(actor_tuple) | |
796 | , converter7::do_(actor_tuple) | |
797 | , converter8::do_(actor_tuple) | |
798 | ); | |
799 | } | |
800 | }; | |
801 | }; | |
802 | ||
803 | #if PHOENIX_LIMIT > 9 | |
804 | ||
805 | ///////////////////////////////////// | |
806 | template <> | |
807 | struct convert_actors_<10> | |
808 | { | |
809 | template <typename TupleResultT, typename ActorTupleT> | |
810 | struct apply | |
811 | { | |
812 | static TupleResultT | |
813 | do_(ActorTupleT const& actor_tuple) | |
814 | { | |
815 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
816 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
817 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
818 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
819 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
820 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
821 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
822 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
823 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
824 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
825 | ||
826 | using namespace tuple_index_names; | |
827 | return TupleResultT( | |
828 | converter0::do_(actor_tuple) | |
829 | , converter1::do_(actor_tuple) | |
830 | , converter2::do_(actor_tuple) | |
831 | , converter3::do_(actor_tuple) | |
832 | , converter4::do_(actor_tuple) | |
833 | , converter5::do_(actor_tuple) | |
834 | , converter6::do_(actor_tuple) | |
835 | , converter7::do_(actor_tuple) | |
836 | , converter8::do_(actor_tuple) | |
837 | , converter9::do_(actor_tuple) | |
838 | ); | |
839 | } | |
840 | }; | |
841 | }; | |
842 | ||
843 | ///////////////////////////////////// | |
844 | template <> | |
845 | struct convert_actors_<11> | |
846 | { | |
847 | template <typename TupleResultT, typename ActorTupleT> | |
848 | struct apply | |
849 | { | |
850 | static TupleResultT | |
851 | do_(ActorTupleT const& actor_tuple) | |
852 | { | |
853 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
854 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
855 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
856 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
857 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
858 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
859 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
860 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
861 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
862 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
863 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
864 | ||
865 | using namespace tuple_index_names; | |
866 | return TupleResultT( | |
867 | converter0::do_(actor_tuple) | |
868 | , converter1::do_(actor_tuple) | |
869 | , converter2::do_(actor_tuple) | |
870 | , converter3::do_(actor_tuple) | |
871 | , converter4::do_(actor_tuple) | |
872 | , converter5::do_(actor_tuple) | |
873 | , converter6::do_(actor_tuple) | |
874 | , converter7::do_(actor_tuple) | |
875 | , converter8::do_(actor_tuple) | |
876 | , converter9::do_(actor_tuple) | |
877 | , converter10::do_(actor_tuple) | |
878 | ); | |
879 | } | |
880 | }; | |
881 | }; | |
882 | ||
883 | ///////////////////////////////////// | |
884 | template <> | |
885 | struct convert_actors_<12> | |
886 | { | |
887 | template <typename TupleResultT, typename ActorTupleT> | |
888 | struct apply | |
889 | { | |
890 | static TupleResultT | |
891 | do_(ActorTupleT const& actor_tuple) | |
892 | { | |
893 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
894 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
895 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
896 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
897 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
898 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
899 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
900 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
901 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
902 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
903 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
904 | typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; | |
905 | ||
906 | using namespace tuple_index_names; | |
907 | return TupleResultT( | |
908 | converter0::do_(actor_tuple) | |
909 | , converter1::do_(actor_tuple) | |
910 | , converter2::do_(actor_tuple) | |
911 | , converter3::do_(actor_tuple) | |
912 | , converter4::do_(actor_tuple) | |
913 | , converter5::do_(actor_tuple) | |
914 | , converter6::do_(actor_tuple) | |
915 | , converter7::do_(actor_tuple) | |
916 | , converter8::do_(actor_tuple) | |
917 | , converter9::do_(actor_tuple) | |
918 | , converter10::do_(actor_tuple) | |
919 | , converter11::do_(actor_tuple) | |
920 | ); | |
921 | } | |
922 | }; | |
923 | }; | |
924 | ||
925 | #if PHOENIX_LIMIT > 12 | |
926 | ||
927 | ///////////////////////////////////// | |
928 | template <> | |
929 | struct convert_actors_<13> | |
930 | { | |
931 | template <typename TupleResultT, typename ActorTupleT> | |
932 | struct apply | |
933 | { | |
934 | static TupleResultT | |
935 | do_(ActorTupleT const& actor_tuple) | |
936 | { | |
937 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
938 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
939 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
940 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
941 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
942 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
943 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
944 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
945 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
946 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
947 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
948 | typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; | |
949 | typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; | |
950 | ||
951 | using namespace tuple_index_names; | |
952 | return TupleResultT( | |
953 | converter0::do_(actor_tuple) | |
954 | , converter1::do_(actor_tuple) | |
955 | , converter2::do_(actor_tuple) | |
956 | , converter3::do_(actor_tuple) | |
957 | , converter4::do_(actor_tuple) | |
958 | , converter5::do_(actor_tuple) | |
959 | , converter6::do_(actor_tuple) | |
960 | , converter7::do_(actor_tuple) | |
961 | , converter8::do_(actor_tuple) | |
962 | , converter9::do_(actor_tuple) | |
963 | , converter10::do_(actor_tuple) | |
964 | , converter11::do_(actor_tuple) | |
965 | , converter12::do_(actor_tuple) | |
966 | ); | |
967 | } | |
968 | }; | |
969 | }; | |
970 | ||
971 | /////////////////////////////////////// | |
972 | template <> | |
973 | struct convert_actors_<14> | |
974 | { | |
975 | template <typename TupleResultT, typename ActorTupleT> | |
976 | struct apply | |
977 | { | |
978 | static TupleResultT | |
979 | do_(ActorTupleT const& actor_tuple) | |
980 | { | |
981 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
982 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
983 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
984 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
985 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
986 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
987 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
988 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
989 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
990 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
991 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
992 | typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; | |
993 | typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; | |
994 | typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; | |
995 | ||
996 | using namespace tuple_index_names; | |
997 | return TupleResultT( | |
998 | converter0::do_(actor_tuple) | |
999 | , converter1::do_(actor_tuple) | |
1000 | , converter2::do_(actor_tuple) | |
1001 | , converter3::do_(actor_tuple) | |
1002 | , converter4::do_(actor_tuple) | |
1003 | , converter5::do_(actor_tuple) | |
1004 | , converter6::do_(actor_tuple) | |
1005 | , converter7::do_(actor_tuple) | |
1006 | , converter8::do_(actor_tuple) | |
1007 | , converter9::do_(actor_tuple) | |
1008 | , converter10::do_(actor_tuple) | |
1009 | , converter11::do_(actor_tuple) | |
1010 | , converter12::do_(actor_tuple) | |
1011 | , converter13::do_(actor_tuple) | |
1012 | ); | |
1013 | } | |
1014 | }; | |
1015 | }; | |
1016 | ||
1017 | /////////////////////////////////////// | |
1018 | template <> | |
1019 | struct convert_actors_<15> | |
1020 | { | |
1021 | template <typename TupleResultT, typename ActorTupleT> | |
1022 | struct apply | |
1023 | { | |
1024 | static TupleResultT | |
1025 | do_(ActorTupleT const& actor_tuple) | |
1026 | { | |
1027 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
1028 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
1029 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
1030 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
1031 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
1032 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
1033 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
1034 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
1035 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
1036 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
1037 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
1038 | typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; | |
1039 | typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; | |
1040 | typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; | |
1041 | typedef impl::convert_actor<14, TupleResultT, ActorTupleT> converter14; | |
1042 | ||
1043 | using namespace tuple_index_names; | |
1044 | return TupleResultT( | |
1045 | converter0::do_(actor_tuple) | |
1046 | , converter1::do_(actor_tuple) | |
1047 | , converter2::do_(actor_tuple) | |
1048 | , converter3::do_(actor_tuple) | |
1049 | , converter4::do_(actor_tuple) | |
1050 | , converter5::do_(actor_tuple) | |
1051 | , converter6::do_(actor_tuple) | |
1052 | , converter7::do_(actor_tuple) | |
1053 | , converter8::do_(actor_tuple) | |
1054 | , converter9::do_(actor_tuple) | |
1055 | , converter10::do_(actor_tuple) | |
1056 | , converter11::do_(actor_tuple) | |
1057 | , converter12::do_(actor_tuple) | |
1058 | , converter13::do_(actor_tuple) | |
1059 | , converter14::do_(actor_tuple) | |
1060 | ); | |
1061 | } | |
1062 | }; | |
1063 | }; | |
1064 | ||
1065 | #endif | |
1066 | #endif | |
1067 | #endif | |
1068 | #endif | |
1069 | } // namespace impl | |
1070 | ||
1071 | ||
1072 | /////////////////////////////////////////////////////////////////////////////// | |
1073 | } // namespace phoenix | |
1074 | ||
1075 | #endif // PHOENIX_TUPLEHELPERS_HPP |