]>
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 | ==============================================================================*/ | |
f67539c2 TL |
9 | #ifndef BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLE_HELPERS_HPP |
10 | #define BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLE_HELPERS_HPP | |
7c673cae FG |
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); | |
1e59de90 TL |
537 | tuple_index<N> const idx; |
538 | return actor_tuple[idx](); // apply the actor | |
7c673cae FG |
539 | } |
540 | ||
541 | static type | |
542 | do_(ActorTupleT const& actor_tuple) | |
543 | { | |
544 | return actor_element( | |
545 | actor_tuple, is_default_t<(N >= ActorTupleT::length)>()); | |
546 | } | |
547 | }; | |
548 | ||
549 | /////////////////////////////////////// | |
550 | template <> | |
551 | struct convert_actors_<1> | |
552 | { | |
553 | template <typename TupleResultT, typename ActorTupleT> | |
554 | struct apply | |
555 | { | |
556 | static TupleResultT | |
557 | do_(ActorTupleT const& actor_tuple) | |
558 | { | |
559 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
560 | ||
561 | return TupleResultT( | |
562 | converter0::do_(actor_tuple) | |
563 | ); | |
564 | } | |
565 | }; | |
566 | }; | |
567 | ||
568 | /////////////////////////////////////// | |
569 | template <> | |
570 | struct convert_actors_<2> | |
571 | { | |
572 | template <typename TupleResultT, typename ActorTupleT> | |
573 | struct apply | |
574 | { | |
575 | static TupleResultT | |
576 | do_(ActorTupleT const& actor_tuple) | |
577 | { | |
578 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
579 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
580 | ||
581 | using namespace tuple_index_names; | |
582 | return TupleResultT( | |
583 | converter0::do_(actor_tuple) | |
584 | , converter1::do_(actor_tuple) | |
585 | ); | |
586 | } | |
587 | }; | |
588 | }; | |
589 | ||
590 | /////////////////////////////////////// | |
591 | template <> | |
592 | struct convert_actors_<3> | |
593 | { | |
594 | template <typename TupleResultT, typename ActorTupleT> | |
595 | struct apply | |
596 | { | |
597 | static TupleResultT | |
598 | do_(ActorTupleT const& actor_tuple) | |
599 | { | |
600 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
601 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
602 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
603 | ||
604 | using namespace tuple_index_names; | |
605 | return TupleResultT( | |
606 | converter0::do_(actor_tuple) | |
607 | , converter1::do_(actor_tuple) | |
608 | , converter2::do_(actor_tuple) | |
609 | ); | |
610 | } | |
611 | }; | |
612 | }; | |
613 | ||
614 | #if PHOENIX_LIMIT > 3 | |
615 | ||
616 | ///////////////////////////////////// | |
617 | template <> | |
618 | struct convert_actors_<4> | |
619 | { | |
620 | template <typename TupleResultT, typename ActorTupleT> | |
621 | struct apply | |
622 | { | |
623 | static TupleResultT | |
624 | do_(ActorTupleT const& actor_tuple) | |
625 | { | |
626 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
627 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
628 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
629 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
630 | ||
631 | using namespace tuple_index_names; | |
632 | return TupleResultT( | |
633 | converter0::do_(actor_tuple) | |
634 | , converter1::do_(actor_tuple) | |
635 | , converter2::do_(actor_tuple) | |
636 | , converter3::do_(actor_tuple) | |
637 | ); | |
638 | } | |
639 | }; | |
640 | }; | |
641 | ||
642 | ///////////////////////////////////// | |
643 | template <> | |
644 | struct convert_actors_<5> | |
645 | { | |
646 | template <typename TupleResultT, typename ActorTupleT> | |
647 | struct apply | |
648 | { | |
649 | static TupleResultT | |
650 | do_(ActorTupleT const& actor_tuple) | |
651 | { | |
652 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
653 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
654 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
655 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
656 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
657 | ||
658 | using namespace tuple_index_names; | |
659 | return TupleResultT( | |
660 | converter0::do_(actor_tuple) | |
661 | , converter1::do_(actor_tuple) | |
662 | , converter2::do_(actor_tuple) | |
663 | , converter3::do_(actor_tuple) | |
664 | , converter4::do_(actor_tuple) | |
665 | ); | |
666 | } | |
667 | }; | |
668 | }; | |
669 | ||
670 | ///////////////////////////////////// | |
671 | template <> | |
672 | struct convert_actors_<6> | |
673 | { | |
674 | template <typename TupleResultT, typename ActorTupleT> | |
675 | struct apply | |
676 | { | |
677 | static TupleResultT | |
678 | do_(ActorTupleT const& actor_tuple) | |
679 | { | |
680 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
681 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
682 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
683 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
684 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
685 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
686 | ||
687 | using namespace tuple_index_names; | |
688 | return TupleResultT( | |
689 | converter0::do_(actor_tuple) | |
690 | , converter1::do_(actor_tuple) | |
691 | , converter2::do_(actor_tuple) | |
692 | , converter3::do_(actor_tuple) | |
693 | , converter4::do_(actor_tuple) | |
694 | , converter5::do_(actor_tuple) | |
695 | ); | |
696 | } | |
697 | }; | |
698 | }; | |
699 | ||
700 | #if PHOENIX_LIMIT > 6 | |
701 | ||
702 | ///////////////////////////////////// | |
703 | template <> | |
704 | struct convert_actors_<7> | |
705 | { | |
706 | template <typename TupleResultT, typename ActorTupleT> | |
707 | struct apply | |
708 | { | |
709 | static TupleResultT | |
710 | do_(ActorTupleT const& actor_tuple) | |
711 | { | |
712 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
713 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
714 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
715 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
716 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
717 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
718 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
719 | ||
720 | using namespace tuple_index_names; | |
721 | return TupleResultT( | |
722 | converter0::do_(actor_tuple) | |
723 | , converter1::do_(actor_tuple) | |
724 | , converter2::do_(actor_tuple) | |
725 | , converter3::do_(actor_tuple) | |
726 | , converter4::do_(actor_tuple) | |
727 | , converter5::do_(actor_tuple) | |
728 | , converter6::do_(actor_tuple) | |
729 | ); | |
730 | } | |
731 | }; | |
732 | }; | |
733 | ||
734 | ///////////////////////////////////// | |
735 | template <> | |
736 | struct convert_actors_<8> | |
737 | { | |
738 | template <typename TupleResultT, typename ActorTupleT> | |
739 | struct apply | |
740 | { | |
741 | static TupleResultT | |
742 | do_(ActorTupleT const& actor_tuple) | |
743 | { | |
744 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
745 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
746 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
747 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
748 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
749 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
750 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
751 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
752 | ||
753 | using namespace tuple_index_names; | |
754 | return TupleResultT( | |
755 | converter0::do_(actor_tuple) | |
756 | , converter1::do_(actor_tuple) | |
757 | , converter2::do_(actor_tuple) | |
758 | , converter3::do_(actor_tuple) | |
759 | , converter4::do_(actor_tuple) | |
760 | , converter5::do_(actor_tuple) | |
761 | , converter6::do_(actor_tuple) | |
762 | , converter7::do_(actor_tuple) | |
763 | ); | |
764 | } | |
765 | }; | |
766 | }; | |
767 | ||
768 | ///////////////////////////////////// | |
769 | template <> | |
770 | struct convert_actors_<9> | |
771 | { | |
772 | template <typename TupleResultT, typename ActorTupleT> | |
773 | struct apply | |
774 | { | |
775 | static TupleResultT | |
776 | do_(ActorTupleT const& actor_tuple) | |
777 | { | |
778 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
779 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
780 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
781 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
782 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
783 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
784 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
785 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
786 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
787 | ||
788 | using namespace tuple_index_names; | |
789 | return TupleResultT( | |
790 | converter0::do_(actor_tuple) | |
791 | , converter1::do_(actor_tuple) | |
792 | , converter2::do_(actor_tuple) | |
793 | , converter3::do_(actor_tuple) | |
794 | , converter4::do_(actor_tuple) | |
795 | , converter5::do_(actor_tuple) | |
796 | , converter6::do_(actor_tuple) | |
797 | , converter7::do_(actor_tuple) | |
798 | , converter8::do_(actor_tuple) | |
799 | ); | |
800 | } | |
801 | }; | |
802 | }; | |
803 | ||
804 | #if PHOENIX_LIMIT > 9 | |
805 | ||
806 | ///////////////////////////////////// | |
807 | template <> | |
808 | struct convert_actors_<10> | |
809 | { | |
810 | template <typename TupleResultT, typename ActorTupleT> | |
811 | struct apply | |
812 | { | |
813 | static TupleResultT | |
814 | do_(ActorTupleT const& actor_tuple) | |
815 | { | |
816 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
817 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
818 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
819 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
820 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
821 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
822 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
823 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
824 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
825 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
826 | ||
827 | using namespace tuple_index_names; | |
828 | return TupleResultT( | |
829 | converter0::do_(actor_tuple) | |
830 | , converter1::do_(actor_tuple) | |
831 | , converter2::do_(actor_tuple) | |
832 | , converter3::do_(actor_tuple) | |
833 | , converter4::do_(actor_tuple) | |
834 | , converter5::do_(actor_tuple) | |
835 | , converter6::do_(actor_tuple) | |
836 | , converter7::do_(actor_tuple) | |
837 | , converter8::do_(actor_tuple) | |
838 | , converter9::do_(actor_tuple) | |
839 | ); | |
840 | } | |
841 | }; | |
842 | }; | |
843 | ||
844 | ///////////////////////////////////// | |
845 | template <> | |
846 | struct convert_actors_<11> | |
847 | { | |
848 | template <typename TupleResultT, typename ActorTupleT> | |
849 | struct apply | |
850 | { | |
851 | static TupleResultT | |
852 | do_(ActorTupleT const& actor_tuple) | |
853 | { | |
854 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
855 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
856 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
857 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
858 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
859 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
860 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
861 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
862 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
863 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
864 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
865 | ||
866 | using namespace tuple_index_names; | |
867 | return TupleResultT( | |
868 | converter0::do_(actor_tuple) | |
869 | , converter1::do_(actor_tuple) | |
870 | , converter2::do_(actor_tuple) | |
871 | , converter3::do_(actor_tuple) | |
872 | , converter4::do_(actor_tuple) | |
873 | , converter5::do_(actor_tuple) | |
874 | , converter6::do_(actor_tuple) | |
875 | , converter7::do_(actor_tuple) | |
876 | , converter8::do_(actor_tuple) | |
877 | , converter9::do_(actor_tuple) | |
878 | , converter10::do_(actor_tuple) | |
879 | ); | |
880 | } | |
881 | }; | |
882 | }; | |
883 | ||
884 | ///////////////////////////////////// | |
885 | template <> | |
886 | struct convert_actors_<12> | |
887 | { | |
888 | template <typename TupleResultT, typename ActorTupleT> | |
889 | struct apply | |
890 | { | |
891 | static TupleResultT | |
892 | do_(ActorTupleT const& actor_tuple) | |
893 | { | |
894 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
895 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
896 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
897 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
898 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
899 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
900 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
901 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
902 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
903 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
904 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
905 | typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; | |
906 | ||
907 | using namespace tuple_index_names; | |
908 | return TupleResultT( | |
909 | converter0::do_(actor_tuple) | |
910 | , converter1::do_(actor_tuple) | |
911 | , converter2::do_(actor_tuple) | |
912 | , converter3::do_(actor_tuple) | |
913 | , converter4::do_(actor_tuple) | |
914 | , converter5::do_(actor_tuple) | |
915 | , converter6::do_(actor_tuple) | |
916 | , converter7::do_(actor_tuple) | |
917 | , converter8::do_(actor_tuple) | |
918 | , converter9::do_(actor_tuple) | |
919 | , converter10::do_(actor_tuple) | |
920 | , converter11::do_(actor_tuple) | |
921 | ); | |
922 | } | |
923 | }; | |
924 | }; | |
925 | ||
926 | #if PHOENIX_LIMIT > 12 | |
927 | ||
928 | ///////////////////////////////////// | |
929 | template <> | |
930 | struct convert_actors_<13> | |
931 | { | |
932 | template <typename TupleResultT, typename ActorTupleT> | |
933 | struct apply | |
934 | { | |
935 | static TupleResultT | |
936 | do_(ActorTupleT const& actor_tuple) | |
937 | { | |
938 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
939 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
940 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
941 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
942 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
943 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
944 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
945 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
946 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
947 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
948 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
949 | typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; | |
950 | typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; | |
951 | ||
952 | using namespace tuple_index_names; | |
953 | return TupleResultT( | |
954 | converter0::do_(actor_tuple) | |
955 | , converter1::do_(actor_tuple) | |
956 | , converter2::do_(actor_tuple) | |
957 | , converter3::do_(actor_tuple) | |
958 | , converter4::do_(actor_tuple) | |
959 | , converter5::do_(actor_tuple) | |
960 | , converter6::do_(actor_tuple) | |
961 | , converter7::do_(actor_tuple) | |
962 | , converter8::do_(actor_tuple) | |
963 | , converter9::do_(actor_tuple) | |
964 | , converter10::do_(actor_tuple) | |
965 | , converter11::do_(actor_tuple) | |
966 | , converter12::do_(actor_tuple) | |
967 | ); | |
968 | } | |
969 | }; | |
970 | }; | |
971 | ||
972 | /////////////////////////////////////// | |
973 | template <> | |
974 | struct convert_actors_<14> | |
975 | { | |
976 | template <typename TupleResultT, typename ActorTupleT> | |
977 | struct apply | |
978 | { | |
979 | static TupleResultT | |
980 | do_(ActorTupleT const& actor_tuple) | |
981 | { | |
982 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
983 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
984 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
985 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
986 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
987 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
988 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
989 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
990 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
991 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
992 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
993 | typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; | |
994 | typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; | |
995 | typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; | |
996 | ||
997 | using namespace tuple_index_names; | |
998 | return TupleResultT( | |
999 | converter0::do_(actor_tuple) | |
1000 | , converter1::do_(actor_tuple) | |
1001 | , converter2::do_(actor_tuple) | |
1002 | , converter3::do_(actor_tuple) | |
1003 | , converter4::do_(actor_tuple) | |
1004 | , converter5::do_(actor_tuple) | |
1005 | , converter6::do_(actor_tuple) | |
1006 | , converter7::do_(actor_tuple) | |
1007 | , converter8::do_(actor_tuple) | |
1008 | , converter9::do_(actor_tuple) | |
1009 | , converter10::do_(actor_tuple) | |
1010 | , converter11::do_(actor_tuple) | |
1011 | , converter12::do_(actor_tuple) | |
1012 | , converter13::do_(actor_tuple) | |
1013 | ); | |
1014 | } | |
1015 | }; | |
1016 | }; | |
1017 | ||
1018 | /////////////////////////////////////// | |
1019 | template <> | |
1020 | struct convert_actors_<15> | |
1021 | { | |
1022 | template <typename TupleResultT, typename ActorTupleT> | |
1023 | struct apply | |
1024 | { | |
1025 | static TupleResultT | |
1026 | do_(ActorTupleT const& actor_tuple) | |
1027 | { | |
1028 | typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; | |
1029 | typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; | |
1030 | typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; | |
1031 | typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; | |
1032 | typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; | |
1033 | typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; | |
1034 | typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; | |
1035 | typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; | |
1036 | typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; | |
1037 | typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; | |
1038 | typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; | |
1039 | typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; | |
1040 | typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; | |
1041 | typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; | |
1042 | typedef impl::convert_actor<14, TupleResultT, ActorTupleT> converter14; | |
1043 | ||
1044 | using namespace tuple_index_names; | |
1045 | return TupleResultT( | |
1046 | converter0::do_(actor_tuple) | |
1047 | , converter1::do_(actor_tuple) | |
1048 | , converter2::do_(actor_tuple) | |
1049 | , converter3::do_(actor_tuple) | |
1050 | , converter4::do_(actor_tuple) | |
1051 | , converter5::do_(actor_tuple) | |
1052 | , converter6::do_(actor_tuple) | |
1053 | , converter7::do_(actor_tuple) | |
1054 | , converter8::do_(actor_tuple) | |
1055 | , converter9::do_(actor_tuple) | |
1056 | , converter10::do_(actor_tuple) | |
1057 | , converter11::do_(actor_tuple) | |
1058 | , converter12::do_(actor_tuple) | |
1059 | , converter13::do_(actor_tuple) | |
1060 | , converter14::do_(actor_tuple) | |
1061 | ); | |
1062 | } | |
1063 | }; | |
1064 | }; | |
1065 | ||
1066 | #endif | |
1067 | #endif | |
1068 | #endif | |
1069 | #endif | |
1070 | } // namespace impl | |
1071 | ||
1072 | ||
1073 | /////////////////////////////////////////////////////////////////////////////// | |
1074 | } // namespace phoenix | |
1075 | ||
f67539c2 | 1076 | #endif |