← Back to branch summary

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

« back to all changes in this revision

Viewing changes to boost/boost/spirit/phoenix/composite.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/composite.hpp
 
1
/*=============================================================================
 
2
    Phoenix V1.0
 
3
    Copyright (c) 2001-2002 Joel de Guzman
 
4
 
 
5
    Permission to copy, use, modify, sell and distribute this software
 
6
    is granted provided this copyright notice appears in all copies.
 
7
    This software is provided "as is" without express or implied
 
8
    warranty, and with no claim as to its suitability for any purpose.
 
9
==============================================================================*/
 
10
#ifndef PHOENIX_COMPOSITE_HPP
 
11
#define PHOENIX_COMPOSITE_HPP
 
12
 
 
13
///////////////////////////////////////////////////////////////////////////////
 
14
#include "boost/spirit/phoenix/actor.hpp"
 
15
 
 
16
///////////////////////////////////////////////////////////////////////////////
 
17
namespace phoenix {
 
18
 
 
19
///////////////////////////////////////////////////////////////////////////////
 
20
//
 
21
//  composite class
 
22
//
 
23
//      A composite is an actor base class composed of zero or more
 
24
//      actors (see actor.hpp) and an operation. A composite is itself
 
25
//      an actor superclass and conforms to its conceptual interface.
 
26
//      Its eval member function un-funnels the tupled actual arguments
 
27
//      from the tuple by invoking each of the actors' eval member
 
28
//      function. The results of each are then passed on as arguments to
 
29
//      the operation. Specializations are provided to handle different
 
30
//      numbers of actors.
 
31
//
 
32
//      Schematically:
 
33
//
 
34
//          actor0.eval(tupled_args) --> arg0 --> |
 
35
//          actor1.eval(tupled_args) --> arg1 --> |
 
36
//          actor2.eval(tupled_args) --> arg3 --> | --> operation(arg0...argN)
 
37
//            ...                                 |
 
38
//          actorN.eval(tupled_args) --> argN --> |
 
39
//
 
40
//      The operation can be any suitable functor that can accept the
 
41
//      arguments passed in by the composite. The operation is expected
 
42
//      to have a member operator() that carries out the actual
 
43
//      operation. There should be a one to one correspondence between
 
44
//      actors of the composite and the arguments of the operation's
 
45
//      member operator().
 
46
//
 
47
//      The operation is also expected to have a nested template class
 
48
//      result<T0...TN>. The nested template class result should have a
 
49
//      typedef 'type' that reflects the return type of its member
 
50
//      operator(). This is essentially a type computer that answers the
 
51
//      metaprogramming question "Given arguments of type T0...TN, what
 
52
//      will be its operator()'s return type?".
 
53
//
 
54
//      There is a special case for operations that accept no arguments.
 
55
//      Such nullary operations are only required to define a typedef
 
56
//      result_type that reflects the return type of its operator().
 
57
//
 
58
//      Here's an example of a simple operation that squares a number:
 
59
//
 
60
//          struct square {
 
61
//
 
62
//              template <typename ArgT>
 
63
//              struct result { typedef ArgT type; };
 
64
//
 
65
//              template <typename ArgT>
 
66
//              ArgT operator()(ArgT n) const { return n * n; }
 
67
//          };
 
68
//
 
69
//      As can be seen, operations can be polymorphic. Its arguments and
 
70
//      return type are not fixed to a particular type. The example
 
71
//      above for example, can handle any ArgT type as long as it has a
 
72
//      multiplication operator.
 
73
//
 
74
//      Composites are not created directly. Instead, there are meta-
 
75
//      programs provided that indirectly create composites. See
 
76
//      operators.hpp, binders.hpp and functions.hpp for examples.
 
77
//
 
78
///////////////////////////////////////////////////////////////////////////////
 
79
template <
 
80
    typename OperationT
 
81
    ,   typename A = nil_t
 
82
    ,   typename B = nil_t
 
83
    ,   typename C = nil_t
 
84
 
 
85
#if PHOENIX_LIMIT > 3
 
86
    ,   typename D = nil_t
 
87
    ,   typename E = nil_t
 
88
    ,   typename F = nil_t
 
89
 
 
90
#if PHOENIX_LIMIT > 6
 
91
    ,   typename G = nil_t
 
92
    ,   typename H = nil_t
 
93
    ,   typename I = nil_t
 
94
 
 
95
#if PHOENIX_LIMIT > 9
 
96
    ,   typename J = nil_t
 
97
    ,   typename K = nil_t
 
98
    ,   typename L = nil_t
 
99
 
 
100
#if PHOENIX_LIMIT > 12
 
101
    ,   typename M = nil_t
 
102
    ,   typename N = nil_t
 
103
    ,   typename O = nil_t
 
104
 
 
105
#endif
 
106
#endif
 
107
#endif
 
108
#endif
 
109
 
 
110
    ,   typename NU = nil_t  // Not used
 
111
>
 
112
struct composite;
 
113
 
 
114
///////////////////////////////////////////////////////////////////////////////
 
115
//
 
116
//  composite <0 actor> class
 
117
//
 
118
///////////////////////////////////////////////////////////////////////////////
 
119
template <typename OperationT, typename TupleT>
 
120
struct composite0_result {
 
121
 
 
122
    typedef typename OperationT::result_type type;
 
123
};
 
124
 
 
125
//////////////////////////////////
 
126
template <typename OperationT>
 
127
struct composite<OperationT,
 
128
    nil_t, nil_t, nil_t,
 
129
#if PHOENIX_LIMIT > 3
 
130
    nil_t, nil_t, nil_t,
 
131
#if PHOENIX_LIMIT > 6
 
132
    nil_t, nil_t, nil_t,
 
133
#if PHOENIX_LIMIT > 9
 
134
    nil_t, nil_t, nil_t,
 
135
#if PHOENIX_LIMIT > 12
 
136
    nil_t, nil_t, nil_t,
 
137
#endif
 
138
#endif
 
139
#endif
 
140
#endif
 
141
    nil_t   //  Unused
 
142
> {
 
143
 
 
144
    typedef composite<OperationT> self_t;
 
145
 
 
146
    template <typename TupleT>
 
147
    struct result {
 
148
 
 
149
        typedef typename composite0_result<
 
150
            OperationT, TupleT
 
151
        >::type type;
 
152
    };
 
153
 
 
154
    composite(OperationT const& op_)
 
155
    :   op(op_) {}
 
156
 
 
157
    template <typename TupleT>
 
158
    typename OperationT::result_type
 
159
    eval(TupleT const& /*args*/) const
 
160
    {
 
161
        return op();
 
162
    }
 
163
 
 
164
    mutable OperationT op; //  operation
 
165
};
 
166
 
 
167
///////////////////////////////////////////////////////////////////////////////
 
168
//
 
169
//  composite <1 actor> class
 
170
//
 
171
///////////////////////////////////////////////////////////////////////////////
 
172
template <typename OperationT, typename TupleT,
 
173
    typename A>
 
174
struct composite1_result {
 
175
 
 
176
    typedef typename OperationT::template result<
 
177
        typename actor_result<A, TupleT>::plain_type
 
178
    >::type type;
 
179
};
 
180
 
 
181
//////////////////////////////////
 
182
template <typename OperationT,
 
183
    typename A>
 
184
struct composite<OperationT,
 
185
    A, nil_t, nil_t,
 
186
#if PHOENIX_LIMIT > 3
 
187
    nil_t, nil_t, nil_t,
 
188
#if PHOENIX_LIMIT > 6
 
189
    nil_t, nil_t, nil_t,
 
190
#if PHOENIX_LIMIT > 9
 
191
    nil_t, nil_t, nil_t,
 
192
#if PHOENIX_LIMIT > 12
 
193
    nil_t, nil_t, nil_t,
 
194
#endif
 
195
#endif
 
196
#endif
 
197
#endif
 
198
    nil_t   //  Unused
 
199
> {
 
200
 
 
201
    typedef composite<OperationT, A> self_t;
 
202
 
 
203
    template <typename TupleT>
 
204
    struct result {
 
205
 
 
206
        typedef typename composite1_result<
 
207
            OperationT, TupleT, A
 
208
        >::type type;
 
209
    };
 
210
 
 
211
    composite(OperationT const& op_,
 
212
        A const& a_)
 
213
    :   op(op_), a(a_) {}
 
214
 
 
215
    template <typename TupleT>
 
216
    typename actor_result<self_t, TupleT>::type
 
217
    eval(TupleT const& args) const
 
218
    {
 
219
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
220
        return op(ra);
 
221
    }
 
222
 
 
223
    mutable OperationT op; //  operation
 
224
    A a; //  actors
 
225
};
 
226
 
 
227
///////////////////////////////////////////////////////////////////////////////
 
228
//
 
229
//  composite <2 actors> class
 
230
//
 
231
///////////////////////////////////////////////////////////////////////////////
 
232
template <typename OperationT, typename TupleT,
 
233
    typename A, typename B>
 
234
struct composite2_result {
 
235
 
 
236
    typedef typename OperationT::template result<
 
237
        typename actor_result<A, TupleT>::plain_type,
 
238
        typename actor_result<B, TupleT>::plain_type
 
239
    >::type type;
 
240
};
 
241
 
 
242
//////////////////////////////////
 
243
template <typename OperationT,
 
244
    typename A, typename B>
 
245
struct composite<OperationT,
 
246
    A, B, nil_t,
 
247
#if PHOENIX_LIMIT > 3
 
248
    nil_t, nil_t, nil_t,
 
249
#if PHOENIX_LIMIT > 6
 
250
    nil_t, nil_t, nil_t,
 
251
#if PHOENIX_LIMIT > 9
 
252
    nil_t, nil_t, nil_t,
 
253
#if PHOENIX_LIMIT > 12
 
254
    nil_t, nil_t, nil_t,
 
255
#endif
 
256
#endif
 
257
#endif
 
258
#endif
 
259
    nil_t   //  Unused
 
260
> {
 
261
 
 
262
    typedef composite<OperationT, A, B> self_t;
 
263
 
 
264
    template <typename TupleT>
 
265
    struct result {
 
266
 
 
267
        typedef typename composite2_result<
 
268
            OperationT, TupleT, A, B
 
269
        >::type type;
 
270
    };
 
271
 
 
272
    composite(OperationT const& op_,
 
273
        A const& a_, B const& b_)
 
274
    :   op(op_), a(a_), b(b_) {}
 
275
 
 
276
    template <typename TupleT>
 
277
    typename actor_result<self_t, TupleT>::type
 
278
    eval(TupleT const& args) const
 
279
    {
 
280
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
281
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
282
        return op(ra, rb);
 
283
    }
 
284
 
 
285
    mutable OperationT op; //  operation
 
286
    A a; B b; //  actors
 
287
};
 
288
 
 
289
///////////////////////////////////////////////////////////////////////////////
 
290
//
 
291
//  composite <3 actors> class
 
292
//
 
293
///////////////////////////////////////////////////////////////////////////////
 
294
template <typename OperationT, typename TupleT,
 
295
    typename A, typename B, typename C>
 
296
struct composite3_result {
 
297
 
 
298
    typedef typename OperationT::template result<
 
299
        typename actor_result<A, TupleT>::plain_type,
 
300
        typename actor_result<B, TupleT>::plain_type,
 
301
        typename actor_result<C, TupleT>::plain_type
 
302
    >::type type;
 
303
};
 
304
 
 
305
//////////////////////////////////
 
306
template <typename OperationT,
 
307
    typename A, typename B, typename C>
 
308
struct composite<OperationT,
 
309
    A, B, C,
 
310
#if PHOENIX_LIMIT > 3
 
311
    nil_t, nil_t, nil_t,
 
312
#if PHOENIX_LIMIT > 6
 
313
    nil_t, nil_t, nil_t,
 
314
#if PHOENIX_LIMIT > 9
 
315
    nil_t, nil_t, nil_t,
 
316
#if PHOENIX_LIMIT > 12
 
317
    nil_t, nil_t, nil_t,
 
318
#endif
 
319
#endif
 
320
#endif
 
321
#endif
 
322
    nil_t   //  Unused
 
323
> {
 
324
 
 
325
    typedef composite<OperationT, A, B, C> self_t;
 
326
 
 
327
    template <typename TupleT>
 
328
    struct result {
 
329
 
 
330
        typedef typename composite3_result<
 
331
            OperationT, TupleT, A, B, C
 
332
        >::type type;
 
333
    };
 
334
 
 
335
    composite(OperationT const& op_,
 
336
        A const& a_, B const& b_, C const& c_)
 
337
    :   op(op_), a(a_), b(b_), c(c_) {}
 
338
 
 
339
    template <typename TupleT>
 
340
    typename actor_result<self_t, TupleT>::type
 
341
    eval(TupleT const& args) const
 
342
    {
 
343
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
344
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
345
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
346
        return op(ra, rb, rc);
 
347
    }
 
348
 
 
349
    mutable OperationT op; //  operation
 
350
    A a; B b; C c; //  actors
 
351
};
 
352
 
 
353
#if PHOENIX_LIMIT > 3
 
354
///////////////////////////////////////////////////////////////////////////////
 
355
//
 
356
//  composite <4 actors> class
 
357
//
 
358
///////////////////////////////////////////////////////////////////////////////
 
359
template <typename OperationT, typename TupleT,
 
360
    typename A, typename B, typename C, typename D>
 
361
struct composite4_result {
 
362
 
 
363
    typedef typename OperationT::template result<
 
364
        typename actor_result<A, TupleT>::plain_type,
 
365
        typename actor_result<B, TupleT>::plain_type,
 
366
        typename actor_result<C, TupleT>::plain_type,
 
367
        typename actor_result<D, TupleT>::plain_type
 
368
    >::type type;
 
369
};
 
370
 
 
371
//////////////////////////////////
 
372
template <typename OperationT,
 
373
    typename A, typename B, typename C, typename D>
 
374
struct composite<OperationT,
 
375
    A, B, C, D, nil_t, nil_t,
 
376
#if PHOENIX_LIMIT > 6
 
377
    nil_t, nil_t, nil_t,
 
378
#if PHOENIX_LIMIT > 9
 
379
    nil_t, nil_t, nil_t,
 
380
#if PHOENIX_LIMIT > 12
 
381
    nil_t, nil_t, nil_t,
 
382
#endif
 
383
#endif
 
384
#endif
 
385
    nil_t   //  Unused
 
386
> {
 
387
 
 
388
    typedef composite<OperationT, A, B, C, D> self_t;
 
389
 
 
390
    template <typename TupleT>
 
391
    struct result {
 
392
 
 
393
        typedef typename composite4_result<
 
394
            OperationT, TupleT, A, B, C, D
 
395
        >::type type;
 
396
    };
 
397
 
 
398
    composite(OperationT const& op_,
 
399
        A const& a_, B const& b_, C const& c_, D const& d_)
 
400
    :   op(op_), a(a_), b(b_), c(c_), d(d_) {}
 
401
 
 
402
    template <typename TupleT>
 
403
    typename actor_result<self_t, TupleT>::type
 
404
    eval(TupleT const& args) const
 
405
    {
 
406
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
407
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
408
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
409
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
410
        return op(ra, rb, rc, rd);
 
411
    }
 
412
 
 
413
    mutable OperationT op; //  operation
 
414
    A a; B b; C c; D d; //  actors
 
415
};
 
416
 
 
417
///////////////////////////////////////////////////////////////////////////////
 
418
//
 
419
//  composite <5 actors> class
 
420
//
 
421
///////////////////////////////////////////////////////////////////////////////
 
422
template <typename OperationT, typename TupleT,
 
423
    typename A, typename B, typename C, typename D, typename E>
 
424
struct composite5_result {
 
425
 
 
426
    typedef typename OperationT::template result<
 
427
        typename actor_result<A, TupleT>::plain_type,
 
428
        typename actor_result<B, TupleT>::plain_type,
 
429
        typename actor_result<C, TupleT>::plain_type,
 
430
        typename actor_result<D, TupleT>::plain_type,
 
431
        typename actor_result<E, TupleT>::plain_type
 
432
    >::type type;
 
433
};
 
434
 
 
435
//////////////////////////////////
 
436
template <typename OperationT,
 
437
    typename A, typename B, typename C, typename D, typename E>
 
438
struct composite<OperationT,
 
439
    A, B, C, D, E, nil_t,
 
440
#if PHOENIX_LIMIT > 6
 
441
    nil_t, nil_t, nil_t,
 
442
#if PHOENIX_LIMIT > 9
 
443
    nil_t, nil_t, nil_t,
 
444
#if PHOENIX_LIMIT > 12
 
445
    nil_t, nil_t, nil_t,
 
446
#endif
 
447
#endif
 
448
#endif
 
449
    nil_t   //  Unused
 
450
> {
 
451
 
 
452
    typedef composite<OperationT, A, B, C, D, E> self_t;
 
453
 
 
454
    template <typename TupleT>
 
455
    struct result {
 
456
 
 
457
        typedef typename composite5_result<
 
458
            OperationT, TupleT, A, B, C, D, E
 
459
        >::type type;
 
460
    };
 
461
 
 
462
    composite(OperationT const& op_,
 
463
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_)
 
464
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_) {}
 
465
 
 
466
    template <typename TupleT>
 
467
    typename actor_result<self_t, TupleT>::type
 
468
    eval(TupleT const& args) const
 
469
    {
 
470
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
471
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
472
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
473
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
474
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
475
        return op(ra, rb, rc, rd, re);
 
476
    }
 
477
 
 
478
    mutable OperationT op; //  operation
 
479
    A a; B b; C c; D d; E e; //  actors
 
480
};
 
481
 
 
482
///////////////////////////////////////////////////////////////////////////////
 
483
//
 
484
//  composite <6 actors> class
 
485
//
 
486
///////////////////////////////////////////////////////////////////////////////
 
487
template <typename OperationT, typename TupleT,
 
488
    typename A, typename B, typename C, typename D, typename E,
 
489
    typename F>
 
490
struct composite6_result {
 
491
 
 
492
    typedef typename OperationT::template result<
 
493
        typename actor_result<A, TupleT>::plain_type,
 
494
        typename actor_result<B, TupleT>::plain_type,
 
495
        typename actor_result<C, TupleT>::plain_type,
 
496
        typename actor_result<D, TupleT>::plain_type,
 
497
        typename actor_result<E, TupleT>::plain_type,
 
498
        typename actor_result<F, TupleT>::plain_type
 
499
    >::type type;
 
500
};
 
501
 
 
502
//////////////////////////////////
 
503
template <typename OperationT,
 
504
    typename A, typename B, typename C, typename D, typename E,
 
505
    typename F>
 
506
struct composite<OperationT,
 
507
    A, B, C, D, E, F,
 
508
#if PHOENIX_LIMIT > 6
 
509
    nil_t, nil_t, nil_t,
 
510
#if PHOENIX_LIMIT > 9
 
511
    nil_t, nil_t, nil_t,
 
512
#if PHOENIX_LIMIT > 12
 
513
    nil_t, nil_t, nil_t,
 
514
#endif
 
515
#endif
 
516
#endif
 
517
    nil_t   //  Unused
 
518
> {
 
519
 
 
520
    typedef composite<OperationT, A, B, C, D, E, F> self_t;
 
521
 
 
522
    template <typename TupleT>
 
523
    struct result {
 
524
 
 
525
        typedef typename composite6_result<
 
526
            OperationT, TupleT, A, B, C, D, E, F
 
527
        >::type type;
 
528
    };
 
529
 
 
530
    composite(OperationT const& op_,
 
531
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
532
        F const& f_)
 
533
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
534
        f(f_) {}
 
535
 
 
536
    template <typename TupleT>
 
537
    typename actor_result<self_t, TupleT>::type
 
538
    eval(TupleT const& args) const
 
539
    {
 
540
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
541
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
542
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
543
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
544
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
545
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
546
        return op(ra, rb, rc, rd, re, rf);
 
547
    }
 
548
 
 
549
    mutable OperationT op; //  operation
 
550
    A a; B b; C c; D d; E e; F f; //  actors
 
551
};
 
552
 
 
553
#if PHOENIX_LIMIT > 6
 
554
///////////////////////////////////////////////////////////////////////////////
 
555
//
 
556
//  composite <7 actors> class
 
557
//
 
558
///////////////////////////////////////////////////////////////////////////////
 
559
template <typename OperationT, typename TupleT,
 
560
    typename A, typename B, typename C, typename D, typename E,
 
561
    typename F, typename G>
 
562
struct composite7_result {
 
563
 
 
564
    typedef typename OperationT::template result<
 
565
        typename actor_result<A, TupleT>::plain_type,
 
566
        typename actor_result<B, TupleT>::plain_type,
 
567
        typename actor_result<C, TupleT>::plain_type,
 
568
        typename actor_result<D, TupleT>::plain_type,
 
569
        typename actor_result<E, TupleT>::plain_type,
 
570
        typename actor_result<F, TupleT>::plain_type,
 
571
        typename actor_result<G, TupleT>::plain_type
 
572
    >::type type;
 
573
};
 
574
 
 
575
//////////////////////////////////
 
576
template <typename OperationT,
 
577
    typename A, typename B, typename C, typename D, typename E,
 
578
    typename F, typename G>
 
579
struct composite<OperationT,
 
580
    A, B, C, D, E, F, G, nil_t, nil_t,
 
581
#if PHOENIX_LIMIT > 9
 
582
    nil_t, nil_t, nil_t,
 
583
#if PHOENIX_LIMIT > 12
 
584
    nil_t, nil_t, nil_t,
 
585
#endif
 
586
#endif
 
587
    nil_t   //  Unused
 
588
> {
 
589
 
 
590
    typedef composite<OperationT, A, B, C, D, E, F, G> self_t;
 
591
 
 
592
    template <typename TupleT>
 
593
    struct result {
 
594
 
 
595
        typedef typename composite7_result<
 
596
            OperationT, TupleT, A, B, C, D, E, F, G
 
597
        >::type type;
 
598
    };
 
599
 
 
600
    composite(OperationT const& op_,
 
601
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
602
        F const& f_, G const& g_)
 
603
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
604
        f(f_), g(g_) {}
 
605
 
 
606
    template <typename TupleT>
 
607
    typename actor_result<self_t, TupleT>::type
 
608
    eval(TupleT const& args) const
 
609
    {
 
610
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
611
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
612
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
613
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
614
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
615
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
616
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
617
        return op(ra, rb, rc, rd, re, rf, rg);
 
618
    }
 
619
 
 
620
    mutable OperationT op; //  operation
 
621
    A a; B b; C c; D d; E e; F f; G g; //  actors
 
622
};
 
623
 
 
624
///////////////////////////////////////////////////////////////////////////////
 
625
//
 
626
//  composite <8 actors> class
 
627
//
 
628
///////////////////////////////////////////////////////////////////////////////
 
629
template <typename OperationT, typename TupleT,
 
630
    typename A, typename B, typename C, typename D, typename E,
 
631
    typename F, typename G, typename H>
 
632
struct composite8_result {
 
633
 
 
634
    typedef typename OperationT::template result<
 
635
        typename actor_result<A, TupleT>::plain_type,
 
636
        typename actor_result<B, TupleT>::plain_type,
 
637
        typename actor_result<C, TupleT>::plain_type,
 
638
        typename actor_result<D, TupleT>::plain_type,
 
639
        typename actor_result<E, TupleT>::plain_type,
 
640
        typename actor_result<F, TupleT>::plain_type,
 
641
        typename actor_result<G, TupleT>::plain_type,
 
642
        typename actor_result<H, TupleT>::plain_type
 
643
    >::type type;
 
644
};
 
645
 
 
646
//////////////////////////////////
 
647
template <typename OperationT,
 
648
    typename A, typename B, typename C, typename D, typename E,
 
649
    typename F, typename G, typename H>
 
650
struct composite<OperationT,
 
651
    A, B, C, D, E, F, G, H, nil_t,
 
652
#if PHOENIX_LIMIT > 9
 
653
    nil_t, nil_t, nil_t,
 
654
#if PHOENIX_LIMIT > 12
 
655
    nil_t, nil_t, nil_t,
 
656
#endif
 
657
#endif
 
658
    nil_t   //  Unused
 
659
> {
 
660
 
 
661
    typedef composite<OperationT, A, B, C, D, E, F, G, H> self_t;
 
662
 
 
663
    template <typename TupleT>
 
664
    struct result {
 
665
 
 
666
        typedef typename composite8_result<
 
667
            OperationT, TupleT, A, B, C, D, E, F, G, H
 
668
        >::type type;
 
669
    };
 
670
 
 
671
    composite(OperationT const& op_,
 
672
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
673
        F const& f_, G const& g_, H const& h_)
 
674
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
675
        f(f_), g(g_), h(h_) {}
 
676
 
 
677
    template <typename TupleT>
 
678
    typename actor_result<self_t, TupleT>::type
 
679
    eval(TupleT const& args) const
 
680
    {
 
681
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
682
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
683
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
684
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
685
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
686
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
687
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
688
        typename actor_result<H, TupleT>::type rh = h.eval(args);
 
689
        return op(ra, rb, rc, rd, re, rf, rg, rh);
 
690
    }
 
691
 
 
692
    mutable OperationT op; //  operation
 
693
    A a; B b; C c; D d; E e; F f; G g; H h; //  actors
 
694
};
 
695
 
 
696
///////////////////////////////////////////////////////////////////////////////
 
697
//
 
698
//  composite <9 actors> class
 
699
//
 
700
///////////////////////////////////////////////////////////////////////////////
 
701
template <typename OperationT, typename TupleT,
 
702
    typename A, typename B, typename C, typename D, typename E,
 
703
    typename F, typename G, typename H, typename I>
 
704
struct composite9_result {
 
705
 
 
706
    typedef typename OperationT::template result<
 
707
        typename actor_result<A, TupleT>::plain_type,
 
708
        typename actor_result<B, TupleT>::plain_type,
 
709
        typename actor_result<C, TupleT>::plain_type,
 
710
        typename actor_result<D, TupleT>::plain_type,
 
711
        typename actor_result<E, TupleT>::plain_type,
 
712
        typename actor_result<F, TupleT>::plain_type,
 
713
        typename actor_result<G, TupleT>::plain_type,
 
714
        typename actor_result<H, TupleT>::plain_type,
 
715
        typename actor_result<I, TupleT>::plain_type
 
716
    >::type type;
 
717
};
 
718
 
 
719
//////////////////////////////////
 
720
template <typename OperationT,
 
721
    typename A, typename B, typename C, typename D, typename E,
 
722
    typename F, typename G, typename H, typename I>
 
723
struct composite<OperationT,
 
724
    A, B, C, D, E, F, G, H, I,
 
725
#if PHOENIX_LIMIT > 9
 
726
    nil_t, nil_t, nil_t,
 
727
#if PHOENIX_LIMIT > 12
 
728
    nil_t, nil_t, nil_t,
 
729
#endif
 
730
#endif
 
731
    nil_t   //  Unused
 
732
> {
 
733
 
 
734
    typedef composite<OperationT, A, B, C, D, E, F, G, H, I> self_t;
 
735
 
 
736
    template <typename TupleT>
 
737
    struct result {
 
738
 
 
739
        typedef typename composite9_result<
 
740
            OperationT, TupleT, A, B, C, D, E, F, G, H, I
 
741
        >::type type;
 
742
    };
 
743
 
 
744
    composite(OperationT const& op_,
 
745
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
746
        F const& f_, G const& g_, H const& h_, I const& i_)
 
747
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
748
        f(f_), g(g_), h(h_), i(i_) {}
 
749
 
 
750
    template <typename TupleT>
 
751
    typename actor_result<self_t, TupleT>::type
 
752
    eval(TupleT const& args) const
 
753
    {
 
754
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
755
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
756
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
757
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
758
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
759
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
760
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
761
        typename actor_result<H, TupleT>::type rh = h.eval(args);
 
762
        typename actor_result<I, TupleT>::type ri = i.eval(args);
 
763
        return op(ra, rb, rc, rd, re, rf, rg, rh, ri);
 
764
    }
 
765
 
 
766
    mutable OperationT op; //  operation
 
767
    A a; B b; C c; D d; E e; F f; G g; H h; I i; //  actors
 
768
};
 
769
 
 
770
#if PHOENIX_LIMIT > 9
 
771
///////////////////////////////////////////////////////////////////////////////
 
772
//
 
773
//  composite <10 actors> class
 
774
//
 
775
///////////////////////////////////////////////////////////////////////////////
 
776
template <typename OperationT, typename TupleT,
 
777
    typename A, typename B, typename C, typename D, typename E,
 
778
    typename F, typename G, typename H, typename I, typename J>
 
779
struct composite10_result {
 
780
 
 
781
    typedef typename OperationT::template result<
 
782
        typename actor_result<A, TupleT>::plain_type,
 
783
        typename actor_result<B, TupleT>::plain_type,
 
784
        typename actor_result<C, TupleT>::plain_type,
 
785
        typename actor_result<D, TupleT>::plain_type,
 
786
        typename actor_result<E, TupleT>::plain_type,
 
787
        typename actor_result<F, TupleT>::plain_type,
 
788
        typename actor_result<G, TupleT>::plain_type,
 
789
        typename actor_result<H, TupleT>::plain_type,
 
790
        typename actor_result<I, TupleT>::plain_type,
 
791
        typename actor_result<J, TupleT>::plain_type
 
792
    >::type type;
 
793
};
 
794
 
 
795
//////////////////////////////////
 
796
template <typename OperationT,
 
797
    typename A, typename B, typename C, typename D, typename E,
 
798
    typename F, typename G, typename H, typename I, typename J>
 
799
struct composite<OperationT,
 
800
    A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
 
801
#if PHOENIX_LIMIT > 12
 
802
    nil_t, nil_t, nil_t,
 
803
#endif
 
804
    nil_t   //  Unused
 
805
> {
 
806
 
 
807
    typedef composite<OperationT, A, B, C, D, E, F, G, H, I, J> self_t;
 
808
 
 
809
    template <typename TupleT>
 
810
    struct result {
 
811
 
 
812
        typedef typename composite10_result<
 
813
            OperationT, TupleT, A, B, C, D, E, F, G, H, I, J
 
814
        >::type type;
 
815
    };
 
816
 
 
817
    composite(OperationT const& op_,
 
818
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
819
        F const& f_, G const& g_, H const& h_, I const& i_, J const& j_)
 
820
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
821
        f(f_), g(g_), h(h_), i(i_), j(j_) {}
 
822
 
 
823
    template <typename TupleT>
 
824
    typename actor_result<self_t, TupleT>::type
 
825
    eval(TupleT const& args) const
 
826
    {
 
827
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
828
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
829
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
830
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
831
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
832
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
833
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
834
        typename actor_result<H, TupleT>::type rh = h.eval(args);
 
835
        typename actor_result<I, TupleT>::type ri = i.eval(args);
 
836
        typename actor_result<J, TupleT>::type rj = j.eval(args);
 
837
        return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj);
 
838
    }
 
839
 
 
840
    mutable OperationT op; //  operation
 
841
    A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; //  actors
 
842
};
 
843
 
 
844
///////////////////////////////////////////////////////////////////////////////
 
845
//
 
846
//  composite <11 actors> class
 
847
//
 
848
///////////////////////////////////////////////////////////////////////////////
 
849
template <typename OperationT, typename TupleT,
 
850
    typename A, typename B, typename C, typename D, typename E,
 
851
    typename F, typename G, typename H, typename I, typename J,
 
852
    typename K>
 
853
struct composite11_result {
 
854
 
 
855
    typedef typename OperationT::template result<
 
856
        typename actor_result<A, TupleT>::plain_type,
 
857
        typename actor_result<B, TupleT>::plain_type,
 
858
        typename actor_result<C, TupleT>::plain_type,
 
859
        typename actor_result<D, TupleT>::plain_type,
 
860
        typename actor_result<E, TupleT>::plain_type,
 
861
        typename actor_result<F, TupleT>::plain_type,
 
862
        typename actor_result<G, TupleT>::plain_type,
 
863
        typename actor_result<H, TupleT>::plain_type,
 
864
        typename actor_result<I, TupleT>::plain_type,
 
865
        typename actor_result<J, TupleT>::plain_type,
 
866
        typename actor_result<K, TupleT>::plain_type
 
867
    >::type type;
 
868
};
 
869
 
 
870
//////////////////////////////////
 
871
template <typename OperationT,
 
872
    typename A, typename B, typename C, typename D, typename E,
 
873
    typename F, typename G, typename H, typename I, typename J,
 
874
    typename K>
 
875
struct composite<OperationT,
 
876
    A, B, C, D, E, F, G, H, I, J, K, nil_t,
 
877
#if PHOENIX_LIMIT > 12
 
878
    nil_t, nil_t, nil_t,
 
879
#endif
 
880
    nil_t   //  Unused
 
881
> {
 
882
 
 
883
    typedef composite<OperationT,
 
884
        A, B, C, D, E, F, G, H, I, J, K> self_t;
 
885
 
 
886
    template <typename TupleT>
 
887
    struct result {
 
888
 
 
889
        typedef typename composite11_result<
 
890
            OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K
 
891
        >::type type;
 
892
    };
 
893
 
 
894
    composite(OperationT const& op_,
 
895
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
896
        F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
 
897
        K const& k_)
 
898
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
899
        f(f_), g(g_), h(h_), i(i_), j(j_),
 
900
        k(k_) {}
 
901
 
 
902
    template <typename TupleT>
 
903
    typename actor_result<self_t, TupleT>::type
 
904
    eval(TupleT const& args) const
 
905
    {
 
906
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
907
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
908
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
909
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
910
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
911
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
912
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
913
        typename actor_result<H, TupleT>::type rh = h.eval(args);
 
914
        typename actor_result<I, TupleT>::type ri = i.eval(args);
 
915
        typename actor_result<J, TupleT>::type rj = j.eval(args);
 
916
        typename actor_result<K, TupleT>::type rk = k.eval(args);
 
917
        return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk);
 
918
    }
 
919
 
 
920
    mutable OperationT op; //  operation
 
921
    A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
 
922
    K k;//  actors
 
923
};
 
924
 
 
925
///////////////////////////////////////////////////////////////////////////////
 
926
//
 
927
//  composite <12 actors> class
 
928
//
 
929
///////////////////////////////////////////////////////////////////////////////
 
930
template <typename OperationT, typename TupleT,
 
931
    typename A, typename B, typename C, typename D, typename E,
 
932
    typename F, typename G, typename H, typename I, typename J,
 
933
    typename K, typename L>
 
934
struct composite12_result {
 
935
 
 
936
    typedef typename OperationT::template result<
 
937
        typename actor_result<A, TupleT>::plain_type,
 
938
        typename actor_result<B, TupleT>::plain_type,
 
939
        typename actor_result<C, TupleT>::plain_type,
 
940
        typename actor_result<D, TupleT>::plain_type,
 
941
        typename actor_result<E, TupleT>::plain_type,
 
942
        typename actor_result<F, TupleT>::plain_type,
 
943
        typename actor_result<G, TupleT>::plain_type,
 
944
        typename actor_result<H, TupleT>::plain_type,
 
945
        typename actor_result<I, TupleT>::plain_type,
 
946
        typename actor_result<J, TupleT>::plain_type,
 
947
        typename actor_result<K, TupleT>::plain_type,
 
948
        typename actor_result<L, TupleT>::plain_type
 
949
    >::type type;
 
950
};
 
951
 
 
952
//////////////////////////////////
 
953
template <typename OperationT,
 
954
    typename A, typename B, typename C, typename D, typename E,
 
955
    typename F, typename G, typename H, typename I, typename J,
 
956
    typename K, typename L>
 
957
struct composite<OperationT,
 
958
    A, B, C, D, E, F, G, H, I, J, K, L,
 
959
#if PHOENIX_LIMIT > 12
 
960
    nil_t, nil_t, nil_t,
 
961
#endif
 
962
    nil_t   //  Unused
 
963
> {
 
964
 
 
965
    typedef composite<OperationT,
 
966
        A, B, C, D, E, F, G, H, I, J, K, L> self_t;
 
967
 
 
968
    template <typename TupleT>
 
969
    struct result {
 
970
 
 
971
        typedef typename composite12_result<
 
972
            OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L
 
973
        >::type type;
 
974
    };
 
975
 
 
976
    composite(OperationT const& op_,
 
977
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
978
        F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
 
979
        K const& k_, L const& l_)
 
980
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
981
        f(f_), g(g_), h(h_), i(i_), j(j_),
 
982
        k(k_), l(l_) {}
 
983
 
 
984
    template <typename TupleT>
 
985
    typename actor_result<self_t, TupleT>::type
 
986
    eval(TupleT const& args) const
 
987
    {
 
988
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
989
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
990
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
991
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
992
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
993
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
994
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
995
        typename actor_result<H, TupleT>::type rh = h.eval(args);
 
996
        typename actor_result<I, TupleT>::type ri = i.eval(args);
 
997
        typename actor_result<J, TupleT>::type rj = j.eval(args);
 
998
        typename actor_result<K, TupleT>::type rk = k.eval(args);
 
999
        typename actor_result<L, TupleT>::type rl = l.eval(args);
 
1000
        return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl);
 
1001
    }
 
1002
 
 
1003
    mutable OperationT op; //  operation
 
1004
    A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
 
1005
    K k; L l;//  actors
 
1006
};
 
1007
 
 
1008
#if PHOENIX_LIMIT > 12
 
1009
///////////////////////////////////////////////////////////////////////////////
 
1010
//
 
1011
//  composite <13 actors> class
 
1012
//
 
1013
///////////////////////////////////////////////////////////////////////////////
 
1014
template <typename OperationT, typename TupleT,
 
1015
    typename A, typename B, typename C, typename D, typename E,
 
1016
    typename F, typename G, typename H, typename I, typename J,
 
1017
    typename K, typename L, typename M>
 
1018
struct composite13_result {
 
1019
 
 
1020
    typedef typename OperationT::template result<
 
1021
        typename actor_result<A, TupleT>::plain_type,
 
1022
        typename actor_result<B, TupleT>::plain_type,
 
1023
        typename actor_result<C, TupleT>::plain_type,
 
1024
        typename actor_result<D, TupleT>::plain_type,
 
1025
        typename actor_result<E, TupleT>::plain_type,
 
1026
        typename actor_result<F, TupleT>::plain_type,
 
1027
        typename actor_result<G, TupleT>::plain_type,
 
1028
        typename actor_result<H, TupleT>::plain_type,
 
1029
        typename actor_result<I, TupleT>::plain_type,
 
1030
        typename actor_result<J, TupleT>::plain_type,
 
1031
        typename actor_result<K, TupleT>::plain_type,
 
1032
        typename actor_result<L, TupleT>::plain_type,
 
1033
        typename actor_result<M, TupleT>::plain_type
 
1034
    >::type type;
 
1035
};
 
1036
 
 
1037
//////////////////////////////////
 
1038
template <typename OperationT,
 
1039
    typename A, typename B, typename C, typename D, typename E,
 
1040
    typename F, typename G, typename H, typename I, typename J,
 
1041
    typename K, typename L, typename M>
 
1042
struct composite<OperationT,
 
1043
    A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t
 
1044
> {
 
1045
 
 
1046
    typedef composite<OperationT,
 
1047
        A, B, C, D, E, F, G, H, I, J, K, L, M> self_t;
 
1048
 
 
1049
    template <typename TupleT>
 
1050
    struct result {
 
1051
 
 
1052
        typedef typename composite13_result<
 
1053
            OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M
 
1054
        >::type type;
 
1055
    };
 
1056
 
 
1057
    composite(OperationT const& op_,
 
1058
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
1059
        F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
 
1060
        K const& k_, L const& l_, M const& m_)
 
1061
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
1062
        f(f_), g(g_), h(h_), i(i_), j(j_),
 
1063
        k(k_), l(l_), m(m_) {}
 
1064
 
 
1065
    template <typename TupleT>
 
1066
    typename actor_result<self_t, TupleT>::type
 
1067
    eval(TupleT const& args) const
 
1068
    {
 
1069
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
1070
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
1071
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
1072
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
1073
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
1074
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
1075
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
1076
        typename actor_result<H, TupleT>::type rh = h.eval(args);
 
1077
        typename actor_result<I, TupleT>::type ri = i.eval(args);
 
1078
        typename actor_result<J, TupleT>::type rj = j.eval(args);
 
1079
        typename actor_result<K, TupleT>::type rk = k.eval(args);
 
1080
        typename actor_result<L, TupleT>::type rl = l.eval(args);
 
1081
        typename actor_result<M, TupleT>::type rm = m.eval(args);
 
1082
        return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm);
 
1083
    }
 
1084
 
 
1085
    mutable OperationT op; //  operation
 
1086
    A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
 
1087
    K k; L l; M m; //  actors
 
1088
};
 
1089
 
 
1090
///////////////////////////////////////////////////////////////////////////////
 
1091
//
 
1092
//  composite <14 actors> class
 
1093
//
 
1094
///////////////////////////////////////////////////////////////////////////////
 
1095
template <typename OperationT, typename TupleT,
 
1096
    typename A, typename B, typename C, typename D, typename E,
 
1097
    typename F, typename G, typename H, typename I, typename J,
 
1098
    typename K, typename L, typename M, typename N>
 
1099
struct composite14_result {
 
1100
 
 
1101
    typedef typename OperationT::template result<
 
1102
        typename actor_result<A, TupleT>::plain_type,
 
1103
        typename actor_result<B, TupleT>::plain_type,
 
1104
        typename actor_result<C, TupleT>::plain_type,
 
1105
        typename actor_result<D, TupleT>::plain_type,
 
1106
        typename actor_result<E, TupleT>::plain_type,
 
1107
        typename actor_result<F, TupleT>::plain_type,
 
1108
        typename actor_result<G, TupleT>::plain_type,
 
1109
        typename actor_result<H, TupleT>::plain_type,
 
1110
        typename actor_result<I, TupleT>::plain_type,
 
1111
        typename actor_result<J, TupleT>::plain_type,
 
1112
        typename actor_result<K, TupleT>::plain_type,
 
1113
        typename actor_result<L, TupleT>::plain_type,
 
1114
        typename actor_result<M, TupleT>::plain_type,
 
1115
        typename actor_result<N, TupleT>::plain_type
 
1116
    >::type type;
 
1117
};
 
1118
 
 
1119
//////////////////////////////////
 
1120
template <typename OperationT,
 
1121
    typename A, typename B, typename C, typename D, typename E,
 
1122
    typename F, typename G, typename H, typename I, typename J,
 
1123
    typename K, typename L, typename M, typename N>
 
1124
struct composite<OperationT,
 
1125
    A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t
 
1126
> {
 
1127
 
 
1128
    typedef composite<OperationT,
 
1129
        A, B, C, D, E, F, G, H, I, J, K, L, M, N> self_t;
 
1130
 
 
1131
    template <typename TupleT>
 
1132
    struct result {
 
1133
 
 
1134
        typedef typename composite14_result<
 
1135
            OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
 
1136
        >::type type;
 
1137
    };
 
1138
 
 
1139
    composite(OperationT const& op_,
 
1140
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
1141
        F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
 
1142
        K const& k_, L const& l_, M const& m_, N const& n_)
 
1143
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
1144
        f(f_), g(g_), h(h_), i(i_), j(j_),
 
1145
        k(k_), l(l_), m(m_), n(n_) {}
 
1146
 
 
1147
    template <typename TupleT>
 
1148
    typename actor_result<self_t, TupleT>::type
 
1149
    eval(TupleT const& args) const
 
1150
    {
 
1151
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
1152
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
1153
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
1154
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
1155
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
1156
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
1157
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
1158
        typename actor_result<H, TupleT>::type rh = h.eval(args);
 
1159
        typename actor_result<I, TupleT>::type ri = i.eval(args);
 
1160
        typename actor_result<J, TupleT>::type rj = j.eval(args);
 
1161
        typename actor_result<K, TupleT>::type rk = k.eval(args);
 
1162
        typename actor_result<L, TupleT>::type rl = l.eval(args);
 
1163
        typename actor_result<M, TupleT>::type rm = m.eval(args);
 
1164
        typename actor_result<N, TupleT>::type rn = n.eval(args);
 
1165
        return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn);
 
1166
    }
 
1167
 
 
1168
    mutable OperationT op; //  operation
 
1169
    A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
 
1170
    K k; L l; M m; N n; //  actors
 
1171
};
 
1172
 
 
1173
///////////////////////////////////////////////////////////////////////////////
 
1174
//
 
1175
//  composite <15 actors> class
 
1176
//
 
1177
///////////////////////////////////////////////////////////////////////////////
 
1178
template <typename OperationT, typename TupleT,
 
1179
    typename A, typename B, typename C, typename D, typename E,
 
1180
    typename F, typename G, typename H, typename I, typename J,
 
1181
    typename K, typename L, typename M, typename N, typename O>
 
1182
struct composite15_result {
 
1183
 
 
1184
    typedef typename OperationT::template result<
 
1185
        typename actor_result<A, TupleT>::plain_type,
 
1186
        typename actor_result<B, TupleT>::plain_type,
 
1187
        typename actor_result<C, TupleT>::plain_type,
 
1188
        typename actor_result<D, TupleT>::plain_type,
 
1189
        typename actor_result<E, TupleT>::plain_type,
 
1190
        typename actor_result<F, TupleT>::plain_type,
 
1191
        typename actor_result<G, TupleT>::plain_type,
 
1192
        typename actor_result<H, TupleT>::plain_type,
 
1193
        typename actor_result<I, TupleT>::plain_type,
 
1194
        typename actor_result<J, TupleT>::plain_type,
 
1195
        typename actor_result<K, TupleT>::plain_type,
 
1196
        typename actor_result<L, TupleT>::plain_type,
 
1197
        typename actor_result<M, TupleT>::plain_type,
 
1198
        typename actor_result<N, TupleT>::plain_type,
 
1199
        typename actor_result<O, TupleT>::plain_type
 
1200
    >::type type;
 
1201
};
 
1202
 
 
1203
//////////////////////////////////
 
1204
template <typename OperationT,
 
1205
    typename A, typename B, typename C, typename D, typename E,
 
1206
    typename F, typename G, typename H, typename I, typename J,
 
1207
    typename K, typename L, typename M, typename N, typename O>
 
1208
struct composite<OperationT,
 
1209
    A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t
 
1210
> {
 
1211
 
 
1212
    typedef composite<OperationT,
 
1213
        A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> self_t;
 
1214
 
 
1215
    template <typename TupleT>
 
1216
    struct result {
 
1217
 
 
1218
        typedef typename composite15_result<
 
1219
            OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
 
1220
        >::type type;
 
1221
    };
 
1222
 
 
1223
    composite(OperationT const& op_,
 
1224
        A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
 
1225
        F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
 
1226
        K const& k_, L const& l_, M const& m_, N const& n_, O const& o_)
 
1227
    :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
 
1228
        f(f_), g(g_), h(h_), i(i_), j(j_),
 
1229
        k(k_), l(l_), m(m_), n(n_), o(o_) {}
 
1230
 
 
1231
    template <typename TupleT>
 
1232
    typename actor_result<self_t, TupleT>::type
 
1233
    eval(TupleT const& args) const
 
1234
    {
 
1235
        typename actor_result<A, TupleT>::type ra = a.eval(args);
 
1236
        typename actor_result<B, TupleT>::type rb = b.eval(args);
 
1237
        typename actor_result<C, TupleT>::type rc = c.eval(args);
 
1238
        typename actor_result<D, TupleT>::type rd = d.eval(args);
 
1239
        typename actor_result<E, TupleT>::type re = e.eval(args);
 
1240
        typename actor_result<F, TupleT>::type rf = f.eval(args);
 
1241
        typename actor_result<G, TupleT>::type rg = g.eval(args);
 
1242
        typename actor_result<H, TupleT>::type rh = h.eval(args);
 
1243
        typename actor_result<I, TupleT>::type ri = i.eval(args);
 
1244
        typename actor_result<J, TupleT>::type rj = j.eval(args);
 
1245
        typename actor_result<K, TupleT>::type rk = k.eval(args);
 
1246
        typename actor_result<L, TupleT>::type rl = l.eval(args);
 
1247
        typename actor_result<M, TupleT>::type rm = m.eval(args);
 
1248
        typename actor_result<N, TupleT>::type rn = n.eval(args);
 
1249
        typename actor_result<O, TupleT>::type ro = o.eval(args);
 
1250
        return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn, ro);
 
1251
    }
 
1252
 
 
1253
    mutable OperationT op; //  operation
 
1254
    A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
 
1255
    K k; L l; M m; N n; O o; //  actors
 
1256
};
 
1257
 
 
1258
#endif
 
1259
#endif
 
1260
#endif
 
1261
#endif
 
1262
 
 
1263
namespace impl {
 
1264
 
 
1265
    ///////////////////////////////////////////////////////////////////////////
 
1266
    //
 
1267
    //      make_composite is basically a type computer that answers the
 
1268
    //      question "Given types T0..TN, what composite type should I
 
1269
    //      create <composite_type> and if I were to generate an actual
 
1270
    //      composite, what type <type> should I return?"
 
1271
    //
 
1272
    ///////////////////////////////////////////////////////////////////////////
 
1273
    template <
 
1274
        typename OperationT
 
1275
        ,   typename A = nil_t
 
1276
        ,   typename B = nil_t
 
1277
        ,   typename C = nil_t
 
1278
 
 
1279
#if PHOENIX_LIMIT > 3
 
1280
        ,   typename D = nil_t
 
1281
        ,   typename E = nil_t
 
1282
        ,   typename F = nil_t
 
1283
 
 
1284
#if PHOENIX_LIMIT > 6
 
1285
        ,   typename G = nil_t
 
1286
        ,   typename H = nil_t
 
1287
        ,   typename I = nil_t
 
1288
 
 
1289
#if PHOENIX_LIMIT > 9
 
1290
        ,   typename J = nil_t
 
1291
        ,   typename K = nil_t
 
1292
        ,   typename L = nil_t
 
1293
 
 
1294
#if PHOENIX_LIMIT > 12
 
1295
        ,   typename M = nil_t
 
1296
        ,   typename N = nil_t
 
1297
        ,   typename O = nil_t
 
1298
 
 
1299
#endif
 
1300
#endif
 
1301
#endif
 
1302
#endif
 
1303
    >
 
1304
    struct make_composite {
 
1305
 
 
1306
        typedef composite<OperationT
 
1307
            ,   typename as_actor<A>::type
 
1308
            ,   typename as_actor<B>::type
 
1309
            ,   typename as_actor<C>::type
 
1310
 
 
1311
#if PHOENIX_LIMIT > 3
 
1312
            ,   typename as_actor<D>::type
 
1313
            ,   typename as_actor<E>::type
 
1314
            ,   typename as_actor<F>::type
 
1315
 
 
1316
#if PHOENIX_LIMIT > 6
 
1317
            ,   typename as_actor<G>::type
 
1318
            ,   typename as_actor<H>::type
 
1319
            ,   typename as_actor<I>::type
 
1320
 
 
1321
#if PHOENIX_LIMIT > 9
 
1322
            ,   typename as_actor<J>::type
 
1323
            ,   typename as_actor<K>::type
 
1324
            ,   typename as_actor<L>::type
 
1325
 
 
1326
#if PHOENIX_LIMIT > 12
 
1327
            ,   typename as_actor<M>::type
 
1328
            ,   typename as_actor<N>::type
 
1329
            ,   typename as_actor<O>::type
 
1330
 
 
1331
#endif
 
1332
#endif
 
1333
#endif
 
1334
#endif
 
1335
        > composite_type;
 
1336
 
 
1337
        typedef actor<composite_type> type;
 
1338
    };
 
1339
 
 
1340
    ///////////////////////////////////////////////////////////////////////////
 
1341
    //
 
1342
    //      make_unary, make_binary, make_binary1, make_binary2 and
 
1343
    //      make_binary3 utilities are provided here for easy creation of
 
1344
    //      unary and binary composites.
 
1345
    //
 
1346
    ///////////////////////////////////////////////////////////////////////////
 
1347
 
 
1348
    //////////////////////////////////  input is an actor
 
1349
    template <typename OperationT, typename BaseT>
 
1350
    struct make_unary {
 
1351
 
 
1352
        typedef typename make_composite
 
1353
            <OperationT, actor<BaseT> >::type type;
 
1354
 
 
1355
        static type
 
1356
        construct(actor<BaseT> const& _0)
 
1357
        {
 
1358
            typedef typename make_composite
 
1359
                    <OperationT, actor<BaseT> >::composite_type
 
1360
                ret_t;
 
1361
 
 
1362
            return ret_t(OperationT(), _0);
 
1363
        }
 
1364
    };
 
1365
 
 
1366
    //////////////////////////////////  LHS is an actor, RHS is unknown
 
1367
    template <typename OperationT, typename BaseT, typename B>
 
1368
    struct make_binary1 {
 
1369
 
 
1370
        typedef typename make_composite
 
1371
            <OperationT, actor<BaseT>, B>::type type;
 
1372
 
 
1373
        static type
 
1374
        construct(actor<BaseT> const& _0, B const& _1)
 
1375
        {
 
1376
            typedef typename make_composite
 
1377
                    <OperationT, actor<BaseT>, B>::composite_type
 
1378
                ret_t;
 
1379
            
 
1380
            return ret_t(OperationT(), _0, as_actor<B>::convert(_1));
 
1381
        }
 
1382
    };
 
1383
 
 
1384
    //////////////////////////////////  LHS is unknown, RHS is an actor
 
1385
    template <typename OperationT, typename A, typename BaseT>
 
1386
    struct make_binary2 {
 
1387
 
 
1388
        typedef typename make_composite
 
1389
            <OperationT, A, actor<BaseT> >::type type;
 
1390
 
 
1391
        static type
 
1392
        construct(A const& _0, actor<BaseT> const& _1)
 
1393
        {
 
1394
            typedef typename make_composite
 
1395
                    <OperationT, A, actor<BaseT> >::composite_type
 
1396
                ret_t;
 
1397
 
 
1398
            return ret_t(OperationT(), as_actor<A>::convert(_0), _1);
 
1399
        }
 
1400
    };
 
1401
 
 
1402
    //////////////////////////////////  Both LHS and RHS are actors
 
1403
    template <typename OperationT, typename BaseA, typename BaseB>
 
1404
    struct make_binary3 {
 
1405
 
 
1406
        typedef typename make_composite
 
1407
            <OperationT, actor<BaseA>, actor<BaseB> >::type type;
 
1408
 
 
1409
        static type
 
1410
        construct(actor<BaseA> const& _0, actor<BaseB> const& _1)
 
1411
        {
 
1412
            typedef typename make_composite
 
1413
                    <OperationT, actor<BaseA>, actor<BaseB> >::composite_type
 
1414
                ret_t;
 
1415
 
 
1416
            return ret_t(OperationT(), _0, _1);
 
1417
        }
 
1418
    };
 
1419
 
 
1420
}
 
1421
 
 
1422
}   //  namespace phoenix
 
1423
 
 
1424
#endif