← Back to branch summary

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

« back to all changes in this revision

Viewing changes to boost/boost/spirit/phoenix/actor.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/actor.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_ACTOR_HPP
 
11
#define PHOENIX_ACTOR_HPP
 
12
 
 
13
///////////////////////////////////////////////////////////////////////////////
 
14
#include "boost/spirit/phoenix/tuples.hpp"
 
15
 
 
16
///////////////////////////////////////////////////////////////////////////////
 
17
namespace phoenix {
 
18
 
 
19
//  These are forward declared here because we cannot include impl.hpp
 
20
//  or operators.hpp yet but the actor's assignment operator and index
 
21
//  operator are required to be members.
 
22
 
 
23
//////////////////////////////////
 
24
struct assign_op;
 
25
struct index_op;
 
26
 
 
27
//////////////////////////////////
 
28
namespace impl {
 
29
 
 
30
    template <typename OperationT, typename BaseT, typename B>
 
31
    struct make_binary1;
 
32
}
 
33
 
 
34
namespace impl {
 
35
 
 
36
    ///////////////////////////////////////////////////////////////////////////
 
37
    //
 
38
    //      if_t selects type A or B depending on the condition C If C is of
 
39
    //      type char[2], B is selected, otherwise A
 
40
    //
 
41
    //      TODO: This should be part of a common meta-library
 
42
    //
 
43
    ///////////////////////////////////////////////////////////////////////////
 
44
    template <typename C, typename A, typename B>
 
45
    struct if_t { typedef A type; };
 
46
 
 
47
    template <typename A, typename B>
 
48
    struct if_t<char[2], A, B> { typedef B type; };
 
49
}
 
50
 
 
51
///////////////////////////////////////////////////////////////////////////////
 
52
//
 
53
//  unpack_tuple class
 
54
//
 
55
//      This class is used to unpack a supplied tuple such, that the members of 
 
56
//      this tuple will be handled as if they would be supplied separately.
 
57
//
 
58
///////////////////////////////////////////////////////////////////////////////
 
59
template <typename TupleT>
 
60
struct unpack_tuple : public TupleT {
 
61
 
 
62
    typedef TupleT tuple_t;
 
63
    
 
64
    unpack_tuple() {}
 
65
    unpack_tuple(tuple_t const &tuple_) : TupleT(tuple_) {}
 
66
};
 
67
 
 
68
///////////////////////////////////////////////////////////////////////////////
 
69
//
 
70
//  actor class
 
71
//
 
72
//      This class is a protocol class for all actors. This class is
 
73
//      essentially an interface contract. The actor class does not
 
74
//      really know how how to act on anything but instead relies on the
 
75
//      template parameter BaseT (from which the actor will derive from)
 
76
//      to do the actual action.
 
77
//
 
78
//      An actor is a functor that is capable of accepting arguments up
 
79
//      to a predefined maximum. It is up to the base class to do the
 
80
//      actual processing or possibly to limit the arity (no. of
 
81
//      arguments) passed in. Upon invocation of the functor through a
 
82
//      supplied operator(), the actor funnels the arguments passed in
 
83
//      by the client into a tuple and calls the base eval member
 
84
//      function.
 
85
//
 
86
//      Schematically:
 
87
//
 
88
//          arg0 ---------|
 
89
//          arg1 ---------|
 
90
//          arg3 ---------|---> tupled_args ---> base.eval
 
91
//          ...           |
 
92
//          argN ---------|
 
93
//
 
94
//          actor::operator()(arg0, arg1... argN)
 
95
//              ---> BaseT::eval(tupled_args);
 
96
//
 
97
//      Actor base classes from which this class inherits from are
 
98
//      expected to have a corresponding member function eval compatible
 
99
//      with the conceptual Interface:
 
100
//
 
101
//          template <typename TupleT>
 
102
//          actor_return_type
 
103
//          eval(TupleT const& args) const;
 
104
//
 
105
//      where args are the actual arguments passed in by the client
 
106
//      funneled into a tuple (see tuple.hpp for details).
 
107
//
 
108
//      The actor_return_type can be anything. Base classes are free to
 
109
//      return any type, even argument dependent types (types that are
 
110
//      deduced from the types of the arguments). After evaluating the
 
111
//      parameters and doing some computations or actions, the eval
 
112
//      member function concludes by returning something back to the
 
113
//      client. To do this, the forwarding function (the actor's
 
114
//      operator()) needs to know the return type of the eval member
 
115
//      function that it is calling. For this purpose, actor base
 
116
//      classes are required to provide a nested template class:
 
117
//
 
118
//          template <typename TupleT>
 
119
//          struct result;
 
120
//
 
121
//      This auxiliary class provides the result type information
 
122
//      returned by the eval member function of a base actor class. The
 
123
//      nested template class result should have a typedef 'type' that
 
124
//      reflects the return type of its member function eval. It is
 
125
//      basically a type computer that answers the question "given
 
126
//      arguments packed into a TupleT type, what will be the result
 
127
//      type of the eval member function of ActorT?". The template class
 
128
//      actor_result queries this to extract the return type of an
 
129
//      actor. Example:
 
130
//
 
131
//          typedef typename actor_result<ActorT, TupleT>::type
 
132
//              actor_return_type;
 
133
//
 
134
//      where actor_return_type is the actual type returned by ActorT's
 
135
//      eval member function given some arguments in a TupleT.
 
136
//
 
137
///////////////////////////////////////////////////////////////////////////////
 
138
template <typename ActorT, typename TupleT>
 
139
struct actor_result {
 
140
 
 
141
    typedef typename ActorT::template result<TupleT>::type type;
 
142
    typedef typename remove_reference<type>::type plain_type;
 
143
};
 
144
 
 
145
//////////////////////////////////
 
146
template <typename BaseT>
 
147
struct actor : public BaseT {
 
148
 
 
149
    actor();
 
150
    actor(BaseT const& base);
 
151
 
 
152
    typename actor_result<BaseT, tuple<> >::type
 
153
    operator()() const;
 
154
 
 
155
    template <typename A>
 
156
    typename actor_result<BaseT, tuple<A&> >::type
 
157
    operator()(A& a) const;
 
158
 
 
159
    template <typename A, typename B>
 
160
    typename actor_result<BaseT, tuple<A&, B&> >::type
 
161
    operator()(A& a, B& b) const;
 
162
 
 
163
    template <typename A, typename B, typename C>
 
164
    typename actor_result<BaseT, tuple<A&, B&, C&> >::type
 
165
    operator()(A& a, B& b, C& c) const;
 
166
 
 
167
#if PHOENIX_LIMIT > 3
 
168
    template <typename A, typename B, typename C, typename D>
 
169
    typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
 
170
    operator()(A& a, B& b, C& c, D& d) const;
 
171
 
 
172
    template <typename A, typename B, typename C, typename D, typename E>
 
173
    typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
 
174
    operator()(A& a, B& b, C& c, D& d, E& e) const;
 
175
 
 
176
    template <
 
177
        typename A, typename B, typename C, typename D, typename E,
 
178
        typename F>
 
179
    typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&, F&> >::type
 
180
    operator()(A& a, B& b, C& c, D& d, E& e, F& f) const;
 
181
 
 
182
#if PHOENIX_LIMIT > 6
 
183
 
 
184
    template <
 
185
        typename A, typename B, typename C, typename D, typename E,
 
186
        typename F, typename G>
 
187
    typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&, F&, G&> >::type
 
188
    operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g) const;
 
189
 
 
190
    template <
 
191
        typename A, typename B, typename C, typename D, typename E,
 
192
        typename F, typename G, typename H>
 
193
    typename actor_result<BaseT,
 
194
        tuple<A&, B&, C&, D&, E&, F&, G&, H&>
 
195
    >::type
 
196
    operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h) const;
 
197
 
 
198
    template <
 
199
        typename A, typename B, typename C, typename D, typename E,
 
200
        typename F, typename G, typename H, typename I>
 
201
    typename actor_result<BaseT,
 
202
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
 
203
    >::type
 
204
    operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i) const;
 
205
 
 
206
#if PHOENIX_LIMIT > 9
 
207
 
 
208
    template <
 
209
        typename A, typename B, typename C, typename D, typename E,
 
210
        typename F, typename G, typename H, typename I, typename J>
 
211
    typename actor_result<BaseT,
 
212
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
 
213
    >::type
 
214
    operator()(
 
215
        A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j) const;
 
216
 
 
217
    template <
 
218
        typename A, typename B, typename C, typename D, typename E,
 
219
        typename F, typename G, typename H, typename I, typename J,
 
220
        typename K>
 
221
    typename actor_result<BaseT,
 
222
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
 
223
    >::type
 
224
    operator()(
 
225
        A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
226
        K& k) const;
 
227
 
 
228
    template <
 
229
        typename A, typename B, typename C, typename D, typename E,
 
230
        typename F, typename G, typename H, typename I, typename J,
 
231
        typename K, typename L>
 
232
    typename actor_result<BaseT,
 
233
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
 
234
    >::type
 
235
    operator()(
 
236
        A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
237
        K& k, L& l) const;
 
238
 
 
239
#if PHOENIX_LIMIT > 12
 
240
 
 
241
    template <
 
242
        typename A, typename B, typename C, typename D, typename E,
 
243
        typename F, typename G, typename H, typename I, typename J,
 
244
        typename K, typename L, typename M>
 
245
    typename actor_result<BaseT,
 
246
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
 
247
    >::type
 
248
    operator()(
 
249
        A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
250
        K& k, L& l, M& m) const;
 
251
 
 
252
    template <
 
253
        typename A, typename B, typename C, typename D, typename E,
 
254
        typename F, typename G, typename H, typename I, typename J,
 
255
        typename K, typename L, typename M, typename N>
 
256
    typename actor_result<BaseT,
 
257
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
 
258
    >::type
 
259
    operator()(
 
260
        A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
261
        K& k, L& l, M& m, N& n) const;
 
262
 
 
263
    template <
 
264
        typename A, typename B, typename C, typename D, typename E,
 
265
        typename F, typename G, typename H, typename I, typename J,
 
266
        typename K, typename L, typename M, typename N, typename O>
 
267
    typename actor_result<BaseT,
 
268
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
 
269
    >::type
 
270
    operator()(
 
271
        A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
272
        K& k, L& l, M& m, N& n, O& o) const;
 
273
 
 
274
#endif
 
275
#endif
 
276
#endif
 
277
#endif
 
278
 
 
279
    template <typename TupleT>
 
280
    typename actor_result<BaseT, unpack_tuple<TupleT> >::type
 
281
    operator()(unpack_tuple<TupleT> const &t) const;
 
282
    
 
283
    template <typename B>
 
284
    typename impl::make_binary1<assign_op, BaseT, B>::type
 
285
    operator=(B const& b) const;
 
286
 
 
287
    template <typename B>
 
288
    typename impl::make_binary1<index_op, BaseT, B>::type
 
289
    operator[](B const& b) const;
 
290
};
 
291
 
 
292
///////////////////////////////////////////////////////////////////////////
 
293
//
 
294
//  as_actor
 
295
//
 
296
//      as_actor is a meta-program that converts an arbitrary type into
 
297
//      an actor. All participants in the framework must be first-class
 
298
//      actors. This meta-program is used all throughout the framework
 
299
//      whenever an unknown type needs to be converted to an actor.
 
300
//      as_actor specializations are expected to have a typedef 'type'.
 
301
//      This is the destination actor type. A static member function
 
302
//      'convert' converts an object to this target type.
 
303
//
 
304
//      The meta-program does no conversion if the object to be
 
305
//      converted is already an actor.
 
306
//
 
307
///////////////////////////////////////////////////////////////////////////
 
308
template <typename T>
 
309
struct as_actor;
 
310
 
 
311
//////////////////////////////////
 
312
template <typename BaseT>
 
313
struct as_actor<actor<BaseT> > {
 
314
 
 
315
    typedef actor<BaseT> type;
 
316
    static type convert(actor<BaseT> const& x) { return x; }
 
317
};
 
318
 
 
319
//////////////////////////////////
 
320
template <>
 
321
struct as_actor<nil_t> {
 
322
 
 
323
    typedef nil_t type;
 
324
    static nil_t convert(nil_t /*x*/)
 
325
    { return nil_t(); }
 
326
};
 
327
 
 
328
//////////////////////////////////
 
329
template <>
 
330
struct as_actor<void> {
 
331
 
 
332
    typedef void type;
 
333
    //  ERROR!!!
 
334
};
 
335
 
 
336
///////////////////////////////////////////////////////////////////////////////
 
337
//
 
338
//  actor class implementation
 
339
//
 
340
///////////////////////////////////////////////////////////////////////////////
 
341
template <typename BaseT>
 
342
actor<BaseT>::actor()
 
343
:   BaseT() {}
 
344
 
 
345
//////////////////////////////////
 
346
template <typename BaseT>
 
347
actor<BaseT>::actor(BaseT const& base)
 
348
:   BaseT(base) {}
 
349
 
 
350
//////////////////////////////////
 
351
template <typename BaseT>
 
352
inline typename actor_result<BaseT, tuple<> >::type
 
353
actor<BaseT>::operator()() const
 
354
{
 
355
    return BaseT::eval(tuple<>());
 
356
}
 
357
 
 
358
//////////////////////////////////
 
359
template <typename BaseT>
 
360
template <typename A>
 
361
inline typename actor_result<BaseT, tuple<A&> >::type
 
362
actor<BaseT>::operator()(A& a) const
 
363
{
 
364
    return BaseT::eval(tuple<A&>(a));
 
365
}
 
366
 
 
367
//////////////////////////////////
 
368
template <typename BaseT>
 
369
template <typename A, typename B>
 
370
inline typename actor_result<BaseT, tuple<A&, B&> >::type
 
371
actor<BaseT>::operator()(A& a, B& b) const
 
372
{
 
373
    return BaseT::eval(tuple<A&, B&>(a, b));
 
374
}
 
375
 
 
376
//////////////////////////////////
 
377
template <typename BaseT>
 
378
template <typename A, typename B, typename C>
 
379
inline typename actor_result<BaseT, tuple<A&, B&, C&> >::type
 
380
actor<BaseT>::operator()(A& a, B& b, C& c) const
 
381
{
 
382
    return BaseT::eval(tuple<A&, B&, C&>(a, b, c));
 
383
}
 
384
 
 
385
#if PHOENIX_LIMIT > 3
 
386
//////////////////////////////////
 
387
template <typename BaseT>
 
388
template <typename A, typename B, typename C, typename D>
 
389
inline typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
 
390
actor<BaseT>::operator()(A& a, B& b, C& c, D& d) const
 
391
{
 
392
    return BaseT::eval(tuple<A&, B&, C&, D&>(a, b, c, d));
 
393
}
 
394
 
 
395
//////////////////////////////////
 
396
template <typename BaseT>
 
397
template <typename A, typename B, typename C, typename D, typename E>
 
398
inline typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
 
399
actor<BaseT>::operator()(A& a, B& b, C& c, D& d, E& e) const
 
400
{
 
401
    return BaseT::eval(tuple<A&, B&, C&, D&, E&>(a, b, c, d, e));
 
402
}
 
403
 
 
404
//////////////////////////////////
 
405
template <typename BaseT>
 
406
template <
 
407
    typename A, typename B, typename C, typename D, typename E,
 
408
    typename F>
 
409
inline typename actor_result<BaseT,
 
410
    tuple<A&, B&, C&, D&, E&, F&>
 
411
>::type
 
412
actor<BaseT>::operator()(
 
413
    A& a, B& b, C& c, D& d, E& e, F& f
 
414
) const
 
415
{
 
416
    return BaseT::eval(
 
417
        tuple<A&, B&, C&, D&, E&, F&>
 
418
        (a, b, c, d, e, f)
 
419
    );
 
420
}
 
421
 
 
422
#if PHOENIX_LIMIT > 6
 
423
//////////////////////////////////
 
424
template <typename BaseT>
 
425
template <
 
426
    typename A, typename B, typename C, typename D, typename E,
 
427
    typename F, typename G>
 
428
inline typename actor_result<BaseT,
 
429
    tuple<A&, B&, C&, D&, E&, F&, G&>
 
430
>::type
 
431
actor<BaseT>::operator()(
 
432
    A& a, B& b, C& c, D& d, E& e, F& f, G& g
 
433
) const
 
434
{
 
435
    return BaseT::eval(
 
436
        tuple<A&, B&, C&, D&, E&, F&, G&>
 
437
        (a, b, c, d, e, f, g)
 
438
    );
 
439
}
 
440
 
 
441
//////////////////////////////////
 
442
template <typename BaseT>
 
443
template <
 
444
    typename A, typename B, typename C, typename D, typename E,
 
445
    typename F, typename G, typename H>
 
446
inline typename actor_result<BaseT,
 
447
    tuple<A&, B&, C&, D&, E&, F&, G&, H&>
 
448
>::type
 
449
actor<BaseT>::operator()(
 
450
    A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h
 
451
) const
 
452
{
 
453
    return BaseT::eval(
 
454
        tuple<A&, B&, C&, D&, E&, F&, G&, H&>
 
455
        (a, b, c, d, e, f, g, h)
 
456
    );
 
457
}
 
458
 
 
459
//////////////////////////////////
 
460
template <typename BaseT>
 
461
template <
 
462
    typename A, typename B, typename C, typename D, typename E,
 
463
    typename F, typename G, typename H, typename I>
 
464
inline typename actor_result<BaseT,
 
465
    tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
 
466
>::type
 
467
actor<BaseT>::operator()(
 
468
    A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i
 
469
) const
 
470
{
 
471
    return BaseT::eval(
 
472
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
 
473
        (a, b, c, d, e, f, g, h, i)
 
474
    );
 
475
}
 
476
 
 
477
#if PHOENIX_LIMIT > 9
 
478
//////////////////////////////////
 
479
template <typename BaseT>
 
480
template <
 
481
    typename A, typename B, typename C, typename D, typename E,
 
482
    typename F, typename G, typename H, typename I, typename J>
 
483
inline typename actor_result<BaseT,
 
484
    tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
 
485
>::type
 
486
actor<BaseT>::operator()(
 
487
    A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j
 
488
) const
 
489
{
 
490
    return BaseT::eval(
 
491
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
 
492
        (a, b, c, d, e, f, g, h, i, j)
 
493
    );
 
494
}
 
495
 
 
496
//////////////////////////////////
 
497
template <typename BaseT>
 
498
template <
 
499
    typename A, typename B, typename C, typename D, typename E,
 
500
    typename F, typename G, typename H, typename I, typename J,
 
501
    typename K>
 
502
inline typename actor_result<BaseT,
 
503
    tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
 
504
>::type
 
505
actor<BaseT>::operator()(
 
506
    A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
507
    K& k
 
508
) const
 
509
{
 
510
    return BaseT::eval(
 
511
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
 
512
        (a, b, c, d, e, f, g, h, i, j, k)
 
513
    );
 
514
}
 
515
 
 
516
//////////////////////////////////
 
517
template <typename BaseT>
 
518
template <
 
519
    typename A, typename B, typename C, typename D, typename E,
 
520
    typename F, typename G, typename H, typename I, typename J,
 
521
    typename K, typename L>
 
522
inline typename actor_result<BaseT,
 
523
    tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
 
524
>::type
 
525
actor<BaseT>::operator()(
 
526
    A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
527
    K& k, L& l
 
528
) const
 
529
{
 
530
    return BaseT::eval(
 
531
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
 
532
        (a, b, c, d, e, f, g, h, i, j, k, l)
 
533
    );
 
534
}
 
535
 
 
536
#if PHOENIX_LIMIT > 12
 
537
//////////////////////////////////
 
538
template <typename BaseT>
 
539
template <
 
540
    typename A, typename B, typename C, typename D, typename E,
 
541
    typename F, typename G, typename H, typename I, typename J,
 
542
    typename K, typename L, typename M>
 
543
inline typename actor_result<BaseT,
 
544
    tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
 
545
>::type
 
546
actor<BaseT>::operator()(
 
547
    A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
548
    K& k, L& l, M& m
 
549
) const
 
550
{
 
551
    return BaseT::eval(
 
552
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
 
553
        (a, b, c, d, e, f, g, h, i, j, k, l, m)
 
554
    );
 
555
}
 
556
 
 
557
//////////////////////////////////
 
558
template <typename BaseT>
 
559
template <
 
560
    typename A, typename B, typename C, typename D, typename E,
 
561
    typename F, typename G, typename H, typename I, typename J,
 
562
    typename K, typename L, typename M, typename N>
 
563
inline typename actor_result<BaseT,
 
564
    tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
 
565
>::type
 
566
actor<BaseT>::operator()(
 
567
    A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
568
    K& k, L& l, M& m, N& n
 
569
) const
 
570
{
 
571
    return BaseT::eval(
 
572
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
 
573
        (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
 
574
    );
 
575
}
 
576
 
 
577
//////////////////////////////////
 
578
template <typename BaseT>
 
579
template <
 
580
    typename A, typename B, typename C, typename D, typename E,
 
581
    typename F, typename G, typename H, typename I, typename J,
 
582
    typename K, typename L, typename M, typename N, typename O>
 
583
inline typename actor_result<BaseT,
 
584
    tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
 
585
>::type
 
586
actor<BaseT>::operator()(
 
587
    A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
 
588
    K& k, L& l, M& m, N& n, O& o
 
589
) const
 
590
{
 
591
    return BaseT::eval(
 
592
        tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
 
593
        (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
 
594
    );
 
595
}
 
596
 
 
597
#endif
 
598
#endif
 
599
#endif
 
600
#endif
 
601
 
 
602
//////////////////////////////////
 
603
template <typename BaseT>
 
604
template <typename TupleT>
 
605
typename actor_result<BaseT, unpack_tuple<TupleT> >::type
 
606
actor<BaseT>::operator()(unpack_tuple<TupleT> const &t) const
 
607
{
 
608
    return BaseT::eval(t);
 
609
}
 
610
 
 
611
///////////////////////////////////////////////////////////////////////////////
 
612
}   //  namespace phoenix
 
613
 
 
614
#endif