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 BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLE_HELPERS_HPP
10 #define BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLE_HELPERS_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
actor_elementphoenix::impl::convert_actor528         actor_element(ActorTupleT const& /*actor_tuple*/, is_default)
529         {
530             return type(); // default construct
531         }
532 
533         static type
actor_elementphoenix::impl::convert_actor534         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
do_phoenix::impl::convert_actor541         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
do_phoenix::impl::convert_actors_::apply556             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
do_phoenix::impl::convert_actors_::apply575             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
do_phoenix::impl::convert_actors_::apply597             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
do_phoenix::impl::convert_actors_::apply623             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
do_phoenix::impl::convert_actors_::apply649             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
do_phoenix::impl::convert_actors_::apply677             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
do_phoenix::impl::convert_actors_::apply709             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
do_phoenix::impl::convert_actors_::apply741             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
do_phoenix::impl::convert_actors_::apply775             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
do_phoenix::impl::convert_actors_::apply813             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
do_phoenix::impl::convert_actors_::apply851             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
do_phoenix::impl::convert_actors_::apply891             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
do_phoenix::impl::convert_actors_::apply935             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
do_phoenix::impl::convert_actors_::apply979             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
do_phoenix::impl::convert_actors_::apply1025             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
1076