← Back to branch summary

~ubuntu-branches/ubuntu/warty/aqsis/warty

« back to all changes in this revision

Viewing changes to boost/boost/spirit/phoenix/tuple_helpers.hpp

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2004-08-24 07:25:04 UTC
  • Revision ID: james.westby@ubuntu.com-20040824072504-zf993vnevvisdsvb
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

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