← Back to branch summary

~ubuntu-branches/debian/sid/boost1.49/sid

« back to all changes in this revision

Viewing changes to boost/phoenix/core/detail/preprocessed/call_20.hpp

  • Committer: Package Import Robot
  • Author(s): Steve M. Robbins
  • Date: 2012-02-26 00:31:44 UTC
  • Revision ID: package-import@ubuntu.com-20120226003144-eaytp12cbf6ubpms
Tags: upstream-1.49.0
Import upstream version 1.49.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/phoenix/core/detail/preprocessed/call_20.hpp
 
1
/*==============================================================================
 
2
    Copyright (c) 2005-2010 Joel de Guzman
 
3
    Copyright (c) 2010 Thomas Heller
 
4
 
 
5
    Distributed under the Boost Software License, Version 1.0. (See accompanying
 
6
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
7
==============================================================================*/
 
8
    
 
9
    namespace detail
 
10
    {
 
11
    
 
12
    
 
13
    
 
14
    
 
15
    
 
16
    
 
17
    
 
18
        
 
19
        template <typename Fun, typename Expr, typename State, typename Data>
 
20
        struct call_impl<Fun, Expr, State, Data, 1>
 
21
            : proto::transform_impl<Expr, State, Data>
 
22
        {
 
23
            typedef
 
24
                typename boost::phoenix::result_of::context<State, Data>::type
 
25
                context_type;
 
26
            typedef typename proto::result_of::child_c<Expr, 0>::type A0;
 
27
            typedef
 
28
                typename boost::result_of<
 
29
                    Fun(A0, context_type)
 
30
                >::type
 
31
                result_type;
 
32
            result_type operator()(
 
33
                typename call_impl::expr_param e
 
34
              , typename call_impl::state_param s
 
35
              , typename call_impl::data_param d
 
36
            ) const
 
37
            {
 
38
                return
 
39
                    Fun()(
 
40
                        proto::child_c< 0>(e)
 
41
                      , boost::phoenix::context(s, d)
 
42
                    );
 
43
            }
 
44
        };
 
45
    
 
46
    
 
47
    
 
48
    
 
49
    
 
50
    
 
51
    
 
52
        
 
53
        template <typename Fun, typename Expr, typename State, typename Data>
 
54
        struct call_impl<Fun, Expr, State, Data, 2>
 
55
            : proto::transform_impl<Expr, State, Data>
 
56
        {
 
57
            typedef
 
58
                typename boost::phoenix::result_of::context<State, Data>::type
 
59
                context_type;
 
60
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1;
 
61
            typedef
 
62
                typename boost::result_of<
 
63
                    Fun(A0 , A1, context_type)
 
64
                >::type
 
65
                result_type;
 
66
            result_type operator()(
 
67
                typename call_impl::expr_param e
 
68
              , typename call_impl::state_param s
 
69
              , typename call_impl::data_param d
 
70
            ) const
 
71
            {
 
72
                return
 
73
                    Fun()(
 
74
                        proto::child_c< 0>(e) , proto::child_c< 1>(e)
 
75
                      , boost::phoenix::context(s, d)
 
76
                    );
 
77
            }
 
78
        };
 
79
    
 
80
    
 
81
    
 
82
    
 
83
    
 
84
    
 
85
    
 
86
        
 
87
        template <typename Fun, typename Expr, typename State, typename Data>
 
88
        struct call_impl<Fun, Expr, State, Data, 3>
 
89
            : proto::transform_impl<Expr, State, Data>
 
90
        {
 
91
            typedef
 
92
                typename boost::phoenix::result_of::context<State, Data>::type
 
93
                context_type;
 
94
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2;
 
95
            typedef
 
96
                typename boost::result_of<
 
97
                    Fun(A0 , A1 , A2, context_type)
 
98
                >::type
 
99
                result_type;
 
100
            result_type operator()(
 
101
                typename call_impl::expr_param e
 
102
              , typename call_impl::state_param s
 
103
              , typename call_impl::data_param d
 
104
            ) const
 
105
            {
 
106
                return
 
107
                    Fun()(
 
108
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e)
 
109
                      , boost::phoenix::context(s, d)
 
110
                    );
 
111
            }
 
112
        };
 
113
    
 
114
    
 
115
    
 
116
    
 
117
    
 
118
    
 
119
    
 
120
        
 
121
        template <typename Fun, typename Expr, typename State, typename Data>
 
122
        struct call_impl<Fun, Expr, State, Data, 4>
 
123
            : proto::transform_impl<Expr, State, Data>
 
124
        {
 
125
            typedef
 
126
                typename boost::phoenix::result_of::context<State, Data>::type
 
127
                context_type;
 
128
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3;
 
129
            typedef
 
130
                typename boost::result_of<
 
131
                    Fun(A0 , A1 , A2 , A3, context_type)
 
132
                >::type
 
133
                result_type;
 
134
            result_type operator()(
 
135
                typename call_impl::expr_param e
 
136
              , typename call_impl::state_param s
 
137
              , typename call_impl::data_param d
 
138
            ) const
 
139
            {
 
140
                return
 
141
                    Fun()(
 
142
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e)
 
143
                      , boost::phoenix::context(s, d)
 
144
                    );
 
145
            }
 
146
        };
 
147
    
 
148
    
 
149
    
 
150
    
 
151
    
 
152
    
 
153
    
 
154
        
 
155
        template <typename Fun, typename Expr, typename State, typename Data>
 
156
        struct call_impl<Fun, Expr, State, Data, 5>
 
157
            : proto::transform_impl<Expr, State, Data>
 
158
        {
 
159
            typedef
 
160
                typename boost::phoenix::result_of::context<State, Data>::type
 
161
                context_type;
 
162
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4;
 
163
            typedef
 
164
                typename boost::result_of<
 
165
                    Fun(A0 , A1 , A2 , A3 , A4, context_type)
 
166
                >::type
 
167
                result_type;
 
168
            result_type operator()(
 
169
                typename call_impl::expr_param e
 
170
              , typename call_impl::state_param s
 
171
              , typename call_impl::data_param d
 
172
            ) const
 
173
            {
 
174
                return
 
175
                    Fun()(
 
176
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e)
 
177
                      , boost::phoenix::context(s, d)
 
178
                    );
 
179
            }
 
180
        };
 
181
    
 
182
    
 
183
    
 
184
    
 
185
    
 
186
    
 
187
    
 
188
        
 
189
        template <typename Fun, typename Expr, typename State, typename Data>
 
190
        struct call_impl<Fun, Expr, State, Data, 6>
 
191
            : proto::transform_impl<Expr, State, Data>
 
192
        {
 
193
            typedef
 
194
                typename boost::phoenix::result_of::context<State, Data>::type
 
195
                context_type;
 
196
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5;
 
197
            typedef
 
198
                typename boost::result_of<
 
199
                    Fun(A0 , A1 , A2 , A3 , A4 , A5, context_type)
 
200
                >::type
 
201
                result_type;
 
202
            result_type operator()(
 
203
                typename call_impl::expr_param e
 
204
              , typename call_impl::state_param s
 
205
              , typename call_impl::data_param d
 
206
            ) const
 
207
            {
 
208
                return
 
209
                    Fun()(
 
210
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e)
 
211
                      , boost::phoenix::context(s, d)
 
212
                    );
 
213
            }
 
214
        };
 
215
    
 
216
    
 
217
    
 
218
    
 
219
    
 
220
    
 
221
    
 
222
        
 
223
        template <typename Fun, typename Expr, typename State, typename Data>
 
224
        struct call_impl<Fun, Expr, State, Data, 7>
 
225
            : proto::transform_impl<Expr, State, Data>
 
226
        {
 
227
            typedef
 
228
                typename boost::phoenix::result_of::context<State, Data>::type
 
229
                context_type;
 
230
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6;
 
231
            typedef
 
232
                typename boost::result_of<
 
233
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6, context_type)
 
234
                >::type
 
235
                result_type;
 
236
            result_type operator()(
 
237
                typename call_impl::expr_param e
 
238
              , typename call_impl::state_param s
 
239
              , typename call_impl::data_param d
 
240
            ) const
 
241
            {
 
242
                return
 
243
                    Fun()(
 
244
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e)
 
245
                      , boost::phoenix::context(s, d)
 
246
                    );
 
247
            }
 
248
        };
 
249
    
 
250
    
 
251
    
 
252
    
 
253
    
 
254
    
 
255
    
 
256
        
 
257
        template <typename Fun, typename Expr, typename State, typename Data>
 
258
        struct call_impl<Fun, Expr, State, Data, 8>
 
259
            : proto::transform_impl<Expr, State, Data>
 
260
        {
 
261
            typedef
 
262
                typename boost::phoenix::result_of::context<State, Data>::type
 
263
                context_type;
 
264
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7;
 
265
            typedef
 
266
                typename boost::result_of<
 
267
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7, context_type)
 
268
                >::type
 
269
                result_type;
 
270
            result_type operator()(
 
271
                typename call_impl::expr_param e
 
272
              , typename call_impl::state_param s
 
273
              , typename call_impl::data_param d
 
274
            ) const
 
275
            {
 
276
                return
 
277
                    Fun()(
 
278
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e)
 
279
                      , boost::phoenix::context(s, d)
 
280
                    );
 
281
            }
 
282
        };
 
283
    
 
284
    
 
285
    
 
286
    
 
287
    
 
288
    
 
289
    
 
290
        
 
291
        template <typename Fun, typename Expr, typename State, typename Data>
 
292
        struct call_impl<Fun, Expr, State, Data, 9>
 
293
            : proto::transform_impl<Expr, State, Data>
 
294
        {
 
295
            typedef
 
296
                typename boost::phoenix::result_of::context<State, Data>::type
 
297
                context_type;
 
298
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8;
 
299
            typedef
 
300
                typename boost::result_of<
 
301
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8, context_type)
 
302
                >::type
 
303
                result_type;
 
304
            result_type operator()(
 
305
                typename call_impl::expr_param e
 
306
              , typename call_impl::state_param s
 
307
              , typename call_impl::data_param d
 
308
            ) const
 
309
            {
 
310
                return
 
311
                    Fun()(
 
312
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e)
 
313
                      , boost::phoenix::context(s, d)
 
314
                    );
 
315
            }
 
316
        };
 
317
    
 
318
    
 
319
    
 
320
    
 
321
    
 
322
    
 
323
    
 
324
        
 
325
        template <typename Fun, typename Expr, typename State, typename Data>
 
326
        struct call_impl<Fun, Expr, State, Data, 10>
 
327
            : proto::transform_impl<Expr, State, Data>
 
328
        {
 
329
            typedef
 
330
                typename boost::phoenix::result_of::context<State, Data>::type
 
331
                context_type;
 
332
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9;
 
333
            typedef
 
334
                typename boost::result_of<
 
335
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9, context_type)
 
336
                >::type
 
337
                result_type;
 
338
            result_type operator()(
 
339
                typename call_impl::expr_param e
 
340
              , typename call_impl::state_param s
 
341
              , typename call_impl::data_param d
 
342
            ) const
 
343
            {
 
344
                return
 
345
                    Fun()(
 
346
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e)
 
347
                      , boost::phoenix::context(s, d)
 
348
                    );
 
349
            }
 
350
        };
 
351
    
 
352
    
 
353
    
 
354
    
 
355
    
 
356
    
 
357
    
 
358
        
 
359
        template <typename Fun, typename Expr, typename State, typename Data>
 
360
        struct call_impl<Fun, Expr, State, Data, 11>
 
361
            : proto::transform_impl<Expr, State, Data>
 
362
        {
 
363
            typedef
 
364
                typename boost::phoenix::result_of::context<State, Data>::type
 
365
                context_type;
 
366
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10;
 
367
            typedef
 
368
                typename boost::result_of<
 
369
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10, context_type)
 
370
                >::type
 
371
                result_type;
 
372
            result_type operator()(
 
373
                typename call_impl::expr_param e
 
374
              , typename call_impl::state_param s
 
375
              , typename call_impl::data_param d
 
376
            ) const
 
377
            {
 
378
                return
 
379
                    Fun()(
 
380
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e)
 
381
                      , boost::phoenix::context(s, d)
 
382
                    );
 
383
            }
 
384
        };
 
385
    
 
386
    
 
387
    
 
388
    
 
389
    
 
390
    
 
391
    
 
392
        
 
393
        template <typename Fun, typename Expr, typename State, typename Data>
 
394
        struct call_impl<Fun, Expr, State, Data, 12>
 
395
            : proto::transform_impl<Expr, State, Data>
 
396
        {
 
397
            typedef
 
398
                typename boost::phoenix::result_of::context<State, Data>::type
 
399
                context_type;
 
400
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11;
 
401
            typedef
 
402
                typename boost::result_of<
 
403
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11, context_type)
 
404
                >::type
 
405
                result_type;
 
406
            result_type operator()(
 
407
                typename call_impl::expr_param e
 
408
              , typename call_impl::state_param s
 
409
              , typename call_impl::data_param d
 
410
            ) const
 
411
            {
 
412
                return
 
413
                    Fun()(
 
414
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e)
 
415
                      , boost::phoenix::context(s, d)
 
416
                    );
 
417
            }
 
418
        };
 
419
    
 
420
    
 
421
    
 
422
    
 
423
    
 
424
    
 
425
    
 
426
        
 
427
        template <typename Fun, typename Expr, typename State, typename Data>
 
428
        struct call_impl<Fun, Expr, State, Data, 13>
 
429
            : proto::transform_impl<Expr, State, Data>
 
430
        {
 
431
            typedef
 
432
                typename boost::phoenix::result_of::context<State, Data>::type
 
433
                context_type;
 
434
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11; typedef typename proto::result_of::child_c<Expr, 12>::type A12;
 
435
            typedef
 
436
                typename boost::result_of<
 
437
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12, context_type)
 
438
                >::type
 
439
                result_type;
 
440
            result_type operator()(
 
441
                typename call_impl::expr_param e
 
442
              , typename call_impl::state_param s
 
443
              , typename call_impl::data_param d
 
444
            ) const
 
445
            {
 
446
                return
 
447
                    Fun()(
 
448
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e) , proto::child_c< 12>(e)
 
449
                      , boost::phoenix::context(s, d)
 
450
                    );
 
451
            }
 
452
        };
 
453
    
 
454
    
 
455
    
 
456
    
 
457
    
 
458
    
 
459
    
 
460
        
 
461
        template <typename Fun, typename Expr, typename State, typename Data>
 
462
        struct call_impl<Fun, Expr, State, Data, 14>
 
463
            : proto::transform_impl<Expr, State, Data>
 
464
        {
 
465
            typedef
 
466
                typename boost::phoenix::result_of::context<State, Data>::type
 
467
                context_type;
 
468
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11; typedef typename proto::result_of::child_c<Expr, 12>::type A12; typedef typename proto::result_of::child_c<Expr, 13>::type A13;
 
469
            typedef
 
470
                typename boost::result_of<
 
471
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13, context_type)
 
472
                >::type
 
473
                result_type;
 
474
            result_type operator()(
 
475
                typename call_impl::expr_param e
 
476
              , typename call_impl::state_param s
 
477
              , typename call_impl::data_param d
 
478
            ) const
 
479
            {
 
480
                return
 
481
                    Fun()(
 
482
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e) , proto::child_c< 12>(e) , proto::child_c< 13>(e)
 
483
                      , boost::phoenix::context(s, d)
 
484
                    );
 
485
            }
 
486
        };
 
487
    
 
488
    
 
489
    
 
490
    
 
491
    
 
492
    
 
493
    
 
494
        
 
495
        template <typename Fun, typename Expr, typename State, typename Data>
 
496
        struct call_impl<Fun, Expr, State, Data, 15>
 
497
            : proto::transform_impl<Expr, State, Data>
 
498
        {
 
499
            typedef
 
500
                typename boost::phoenix::result_of::context<State, Data>::type
 
501
                context_type;
 
502
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11; typedef typename proto::result_of::child_c<Expr, 12>::type A12; typedef typename proto::result_of::child_c<Expr, 13>::type A13; typedef typename proto::result_of::child_c<Expr, 14>::type A14;
 
503
            typedef
 
504
                typename boost::result_of<
 
505
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14, context_type)
 
506
                >::type
 
507
                result_type;
 
508
            result_type operator()(
 
509
                typename call_impl::expr_param e
 
510
              , typename call_impl::state_param s
 
511
              , typename call_impl::data_param d
 
512
            ) const
 
513
            {
 
514
                return
 
515
                    Fun()(
 
516
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e) , proto::child_c< 12>(e) , proto::child_c< 13>(e) , proto::child_c< 14>(e)
 
517
                      , boost::phoenix::context(s, d)
 
518
                    );
 
519
            }
 
520
        };
 
521
    
 
522
    
 
523
    
 
524
    
 
525
    
 
526
    
 
527
    
 
528
        
 
529
        template <typename Fun, typename Expr, typename State, typename Data>
 
530
        struct call_impl<Fun, Expr, State, Data, 16>
 
531
            : proto::transform_impl<Expr, State, Data>
 
532
        {
 
533
            typedef
 
534
                typename boost::phoenix::result_of::context<State, Data>::type
 
535
                context_type;
 
536
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11; typedef typename proto::result_of::child_c<Expr, 12>::type A12; typedef typename proto::result_of::child_c<Expr, 13>::type A13; typedef typename proto::result_of::child_c<Expr, 14>::type A14; typedef typename proto::result_of::child_c<Expr, 15>::type A15;
 
537
            typedef
 
538
                typename boost::result_of<
 
539
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15, context_type)
 
540
                >::type
 
541
                result_type;
 
542
            result_type operator()(
 
543
                typename call_impl::expr_param e
 
544
              , typename call_impl::state_param s
 
545
              , typename call_impl::data_param d
 
546
            ) const
 
547
            {
 
548
                return
 
549
                    Fun()(
 
550
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e) , proto::child_c< 12>(e) , proto::child_c< 13>(e) , proto::child_c< 14>(e) , proto::child_c< 15>(e)
 
551
                      , boost::phoenix::context(s, d)
 
552
                    );
 
553
            }
 
554
        };
 
555
    
 
556
    
 
557
    
 
558
    
 
559
    
 
560
    
 
561
    
 
562
        
 
563
        template <typename Fun, typename Expr, typename State, typename Data>
 
564
        struct call_impl<Fun, Expr, State, Data, 17>
 
565
            : proto::transform_impl<Expr, State, Data>
 
566
        {
 
567
            typedef
 
568
                typename boost::phoenix::result_of::context<State, Data>::type
 
569
                context_type;
 
570
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11; typedef typename proto::result_of::child_c<Expr, 12>::type A12; typedef typename proto::result_of::child_c<Expr, 13>::type A13; typedef typename proto::result_of::child_c<Expr, 14>::type A14; typedef typename proto::result_of::child_c<Expr, 15>::type A15; typedef typename proto::result_of::child_c<Expr, 16>::type A16;
 
571
            typedef
 
572
                typename boost::result_of<
 
573
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16, context_type)
 
574
                >::type
 
575
                result_type;
 
576
            result_type operator()(
 
577
                typename call_impl::expr_param e
 
578
              , typename call_impl::state_param s
 
579
              , typename call_impl::data_param d
 
580
            ) const
 
581
            {
 
582
                return
 
583
                    Fun()(
 
584
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e) , proto::child_c< 12>(e) , proto::child_c< 13>(e) , proto::child_c< 14>(e) , proto::child_c< 15>(e) , proto::child_c< 16>(e)
 
585
                      , boost::phoenix::context(s, d)
 
586
                    );
 
587
            }
 
588
        };
 
589
    
 
590
    
 
591
    
 
592
    
 
593
    
 
594
    
 
595
    
 
596
        
 
597
        template <typename Fun, typename Expr, typename State, typename Data>
 
598
        struct call_impl<Fun, Expr, State, Data, 18>
 
599
            : proto::transform_impl<Expr, State, Data>
 
600
        {
 
601
            typedef
 
602
                typename boost::phoenix::result_of::context<State, Data>::type
 
603
                context_type;
 
604
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11; typedef typename proto::result_of::child_c<Expr, 12>::type A12; typedef typename proto::result_of::child_c<Expr, 13>::type A13; typedef typename proto::result_of::child_c<Expr, 14>::type A14; typedef typename proto::result_of::child_c<Expr, 15>::type A15; typedef typename proto::result_of::child_c<Expr, 16>::type A16; typedef typename proto::result_of::child_c<Expr, 17>::type A17;
 
605
            typedef
 
606
                typename boost::result_of<
 
607
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17, context_type)
 
608
                >::type
 
609
                result_type;
 
610
            result_type operator()(
 
611
                typename call_impl::expr_param e
 
612
              , typename call_impl::state_param s
 
613
              , typename call_impl::data_param d
 
614
            ) const
 
615
            {
 
616
                return
 
617
                    Fun()(
 
618
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e) , proto::child_c< 12>(e) , proto::child_c< 13>(e) , proto::child_c< 14>(e) , proto::child_c< 15>(e) , proto::child_c< 16>(e) , proto::child_c< 17>(e)
 
619
                      , boost::phoenix::context(s, d)
 
620
                    );
 
621
            }
 
622
        };
 
623
    
 
624
    
 
625
    
 
626
    
 
627
    
 
628
    
 
629
    
 
630
        
 
631
        template <typename Fun, typename Expr, typename State, typename Data>
 
632
        struct call_impl<Fun, Expr, State, Data, 19>
 
633
            : proto::transform_impl<Expr, State, Data>
 
634
        {
 
635
            typedef
 
636
                typename boost::phoenix::result_of::context<State, Data>::type
 
637
                context_type;
 
638
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11; typedef typename proto::result_of::child_c<Expr, 12>::type A12; typedef typename proto::result_of::child_c<Expr, 13>::type A13; typedef typename proto::result_of::child_c<Expr, 14>::type A14; typedef typename proto::result_of::child_c<Expr, 15>::type A15; typedef typename proto::result_of::child_c<Expr, 16>::type A16; typedef typename proto::result_of::child_c<Expr, 17>::type A17; typedef typename proto::result_of::child_c<Expr, 18>::type A18;
 
639
            typedef
 
640
                typename boost::result_of<
 
641
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18, context_type)
 
642
                >::type
 
643
                result_type;
 
644
            result_type operator()(
 
645
                typename call_impl::expr_param e
 
646
              , typename call_impl::state_param s
 
647
              , typename call_impl::data_param d
 
648
            ) const
 
649
            {
 
650
                return
 
651
                    Fun()(
 
652
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e) , proto::child_c< 12>(e) , proto::child_c< 13>(e) , proto::child_c< 14>(e) , proto::child_c< 15>(e) , proto::child_c< 16>(e) , proto::child_c< 17>(e) , proto::child_c< 18>(e)
 
653
                      , boost::phoenix::context(s, d)
 
654
                    );
 
655
            }
 
656
        };
 
657
    
 
658
    
 
659
    
 
660
    
 
661
    
 
662
    
 
663
    
 
664
        
 
665
        template <typename Fun, typename Expr, typename State, typename Data>
 
666
        struct call_impl<Fun, Expr, State, Data, 20>
 
667
            : proto::transform_impl<Expr, State, Data>
 
668
        {
 
669
            typedef
 
670
                typename boost::phoenix::result_of::context<State, Data>::type
 
671
                context_type;
 
672
            typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9; typedef typename proto::result_of::child_c<Expr, 10>::type A10; typedef typename proto::result_of::child_c<Expr, 11>::type A11; typedef typename proto::result_of::child_c<Expr, 12>::type A12; typedef typename proto::result_of::child_c<Expr, 13>::type A13; typedef typename proto::result_of::child_c<Expr, 14>::type A14; typedef typename proto::result_of::child_c<Expr, 15>::type A15; typedef typename proto::result_of::child_c<Expr, 16>::type A16; typedef typename proto::result_of::child_c<Expr, 17>::type A17; typedef typename proto::result_of::child_c<Expr, 18>::type A18; typedef typename proto::result_of::child_c<Expr, 19>::type A19;
 
673
            typedef
 
674
                typename boost::result_of<
 
675
                    Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19, context_type)
 
676
                >::type
 
677
                result_type;
 
678
            result_type operator()(
 
679
                typename call_impl::expr_param e
 
680
              , typename call_impl::state_param s
 
681
              , typename call_impl::data_param d
 
682
            ) const
 
683
            {
 
684
                return
 
685
                    Fun()(
 
686
                        proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e) , proto::child_c< 10>(e) , proto::child_c< 11>(e) , proto::child_c< 12>(e) , proto::child_c< 13>(e) , proto::child_c< 14>(e) , proto::child_c< 15>(e) , proto::child_c< 16>(e) , proto::child_c< 17>(e) , proto::child_c< 18>(e) , proto::child_c< 19>(e)
 
687
                      , boost::phoenix::context(s, d)
 
688
                    );
 
689
            }
 
690
        };
 
691
    }