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///////////////////////////////////////////////////////////////////////////////
17namespace 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)
31template <typename ResultT>
32struct make_tuple {
33
34 typedef tuple<ResultT> type;
35};
36
37///////////////////////////////////////////////////////////////////////////////
38// nil_t is converted to an empty tuple type
39template <>
40struct make_tuple<nil_t> {
41
42 typedef tuple<> type;
43};
44
45///////////////////////////////////////////////////////////////////////////////
46// tuple types are left alone without any refactoring
47template <
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>
62struct 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///////////////////////////////////////////////////////////////////////////////
102template <typename TupleT, typename AppendT>
103struct concat_tuple;
104
105///////////////////////////////////////////////////////////////////////////////
106//
107// concat tuple <0 member> class
108//
109///////////////////////////////////////////////////////////////////////////////
110template <typename AppendT>
111struct concat_tuple<tuple<>, AppendT> {
112
113 typedef tuple<AppendT> type;
114};
115
116template <>
117struct concat_tuple<tuple<>, nil_t> {
118
119 typedef tuple<> type;
120};
121
122///////////////////////////////////////////////////////////////////////////////
123//
124// concat tuple <1 member> class
125//
126///////////////////////////////////////////////////////////////////////////////
127template <typename A, typename AppendT>
128struct concat_tuple<tuple<A>, AppendT> {
129
130 typedef tuple<A, AppendT> type;
131};
132
133template <typename A>
134struct concat_tuple<tuple<A>, nil_t> {
135
136 typedef tuple<A> type;
137};
138
139///////////////////////////////////////////////////////////////////////////////
140//
141// concat tuple <2 member> class
142//
143///////////////////////////////////////////////////////////////////////////////
144template <typename A, typename B, typename AppendT>
145struct concat_tuple<tuple<A, B>, AppendT> {
146
147 typedef tuple<A, B, AppendT> type;
148};
149
150template <typename A, typename B>
151struct 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///////////////////////////////////////////////////////////////////////////////
162template <
163 typename A, typename B, typename C,
164 typename AppendT
165>
166struct concat_tuple<tuple<A, B, C>, AppendT> {
167
168 typedef tuple<A, B, C, AppendT> type;
169};
170
171template <
172 typename A, typename B, typename C
173>
174struct 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///////////////////////////////////////////////////////////////////////////////
184template <
185 typename A, typename B, typename C, typename D,
186 typename AppendT
187>
188struct concat_tuple<tuple<A, B, C, D>, AppendT> {
189
190 typedef tuple<A, B, C, D, AppendT> type;
191};
192
193template <
194 typename A, typename B, typename C, typename D
195>
196struct 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///////////////////////////////////////////////////////////////////////////////
206template <
207 typename A, typename B, typename C, typename D, typename E,
208 typename AppendT
209>
210struct concat_tuple<tuple<A, B, C, D, E>, AppendT> {
211
212 typedef tuple<A, B, C, D, E, AppendT> type;
213};
214
215template <
216 typename A, typename B, typename C, typename D, typename E
217>
218struct 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///////////////////////////////////////////////////////////////////////////////
229template <
230 typename A, typename B, typename C, typename D, typename E, typename F,
231 typename AppendT
232>
233struct concat_tuple<tuple<A, B, C, D, E, F>, AppendT> {
234
235 typedef tuple<A, B, C, D, E, F, AppendT> type;
236};
237
238template <
239 typename A, typename B, typename C, typename D, typename E, typename F
240>
241struct 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///////////////////////////////////////////////////////////////////////////////
251template <
252 typename A, typename B, typename C, typename D, typename E, typename F,
253 typename G,
254 typename AppendT
255>
256struct 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
261template <
262 typename A, typename B, typename C, typename D, typename E, typename F,
263 typename G
264>
265struct 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///////////////////////////////////////////////////////////////////////////////
275template <
276 typename A, typename B, typename C, typename D, typename E, typename F,
277 typename G, typename H,
278 typename AppendT
279>
280struct 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
285template <
286 typename A, typename B, typename C, typename D, typename E, typename F,
287 typename G, typename H
288>
289struct 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///////////////////////////////////////////////////////////////////////////////
300template <
301 typename A, typename B, typename C, typename D, typename E, typename F,
302 typename G, typename H, typename I,
303 typename AppendT
304>
305struct 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
310template <
311 typename A, typename B, typename C, typename D, typename E, typename F,
312 typename G, typename H, typename I
313>
314struct 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///////////////////////////////////////////////////////////////////////////////
324template <
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>
329struct 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
334template <
335 typename A, typename B, typename C, typename D, typename E, typename F,
336 typename G, typename H, typename I, typename J
337>
338struct 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///////////////////////////////////////////////////////////////////////////////
348template <
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>
353struct 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
358template <
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>
362struct 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///////////////////////////////////////////////////////////////////////////////
373template <
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>
378struct 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
383template <
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>
387struct 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///////////////////////////////////////////////////////////////////////////////
397template <
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>
403struct 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
408template <
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>
413struct 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///////////////////////////////////////////////////////////////////////////////
423template <
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>
429struct 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
434template <
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>
439struct 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///////////////////////////////////////////////////////////////////////////////
457template <typename TupleT1, typename TupleT2, int N, typename AppendT>
458struct 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
468template <typename TupleT1, typename TupleT2, int N>
469struct concat_tuple_element<TupleT1, TupleT2, N, nil_t> {
470
471 typedef TupleT1 type;
472};
473
474template <typename TupleT1, typename TupleT2>
475struct 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///////////////////////////////////////////////////////////////////////////////
496template <typename ActorT, typename TupleT>
497struct actor_result; // forward declaration
498
499namespace impl
500{
501 template <unsigned N>
502 struct convert_actors_ {};
503}
504
505template <typename TupleResultT, typename ActorTupleT>
506TupleResultT
507convert_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
515namespace 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 tuple_index<N> const idx;
538 return actor_tuple[idx](); // apply the actor
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
1076#endif
1077

source code of boost/libs/spirit/include/boost/spirit/home/classic/phoenix/tuple_helpers.hpp