• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1     ///////////////////////////////////////////////////////////////////////////////
2     /// \file traits.hpp
3     /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c
4     //
5     //  Copyright 2008 Eric Niebler. Distributed under the Boost
6     //  Software License, Version 1.0. (See accompanying file
7     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8         namespace result_of
9         {
10 
11 
12 
13 
14 
15 
16             template<typename Expr>
17             struct child_c<Expr, 0>
18             {
19 
20                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
21 
22 
23                 typedef typename Expr::proto_child0 value_type;
24 
25 
26 
27 
28 
29                 typedef typename detail::expr_traits<typename Expr::proto_child0>::value_type type;
30             };
31             template<typename Expr>
32             struct child_c<Expr &, 0>
33             {
34 
35                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
36 
37 
38                 typedef typename Expr::proto_child0 value_type;
39 
40 
41 
42 
43 
44                 typedef typename detail::expr_traits<typename Expr::proto_child0>::reference type;
45 
46 
47                 BOOST_FORCEINLINE
callresult_of::child_c48                 static type call(Expr &e)
49                 {
50                     return e.proto_base().child0;
51                 }
52             };
53             template<typename Expr>
54             struct child_c<Expr const &, 0>
55             {
56 
57                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
58 
59 
60                 typedef typename Expr::proto_child0 value_type;
61 
62 
63 
64 
65 
66                 typedef typename detail::expr_traits<typename Expr::proto_child0>::const_reference type;
67 
68 
69                 BOOST_FORCEINLINE
callresult_of::child_c70                 static type call(Expr const &e)
71                 {
72                     return e.proto_base().child0;
73                 }
74             };
75         }
76 
77 
78 
79 
80         template<typename A0>
81         struct function
82         <
83             A0
84             , void , void , void , void , void , void , void , void , void
85         >
86           : proto::transform<
87                 function<
88                     A0
89                     , void , void , void , void , void , void , void , void , void
90                 >
91               , int
92             >
93         {
94             typedef proto::expr<proto::tag::function, list1<A0>, 1> type;
95             typedef proto::basic_expr<proto::tag::function, list1<A0>, 1> proto_grammar;
96             template<typename Expr, typename State, typename Data>
97             struct impl
98               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
99             {};
100 
101             typedef proto::tag::function proto_tag;
102             typedef A0 proto_child0;
103             typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9;
104         };
105 
106 
107 
108 
109 
110 
111 
112 
113         template<typename Tag , typename A0>
114         struct nary_expr
115         <
116             Tag
117             , A0
118             , void , void , void , void , void , void , void , void , void
119         >
120           : proto::transform<
121                 nary_expr<
122                     Tag
123                     , A0
124                     , void , void , void , void , void , void , void , void , void
125                 >
126               , int
127             >
128         {
129             typedef proto::expr<Tag, list1<A0>, 1> type;
130             typedef proto::basic_expr<Tag, list1<A0>, 1> proto_grammar;
131             template<typename Expr, typename State, typename Data>
132             struct impl
133               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
134             {};
135 
136             typedef Tag proto_tag;
137             typedef A0 proto_child0;
138             typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9;
139         };
140         namespace detail
141         {
142             template<
143                 template<typename> class T
144               , typename A0
145             >
146             struct is_callable_<T<A0> BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)>
147               : is_same<A0, callable>
148             {};
149         }
150         namespace result_of
151         {
152 
153 
154 
155 
156 
157 
158             template<typename Expr>
159             struct child_c<Expr, 1>
160             {
161 
162                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
163 
164 
165                 typedef typename Expr::proto_child1 value_type;
166 
167 
168 
169 
170 
171                 typedef typename detail::expr_traits<typename Expr::proto_child1>::value_type type;
172             };
173             template<typename Expr>
174             struct child_c<Expr &, 1>
175             {
176 
177                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
178 
179 
180                 typedef typename Expr::proto_child1 value_type;
181 
182 
183 
184 
185 
186                 typedef typename detail::expr_traits<typename Expr::proto_child1>::reference type;
187 
188 
189                 BOOST_FORCEINLINE
callresult_of::child_c190                 static type call(Expr &e)
191                 {
192                     return e.proto_base().child1;
193                 }
194             };
195             template<typename Expr>
196             struct child_c<Expr const &, 1>
197             {
198 
199                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
200 
201 
202                 typedef typename Expr::proto_child1 value_type;
203 
204 
205 
206 
207 
208                 typedef typename detail::expr_traits<typename Expr::proto_child1>::const_reference type;
209 
210 
211                 BOOST_FORCEINLINE
callresult_of::child_c212                 static type call(Expr const &e)
213                 {
214                     return e.proto_base().child1;
215                 }
216             };
217         }
218 
219 
220 
221 
222         template<typename A0 , typename A1>
223         struct function
224         <
225             A0 , A1
226             , void , void , void , void , void , void , void , void
227         >
228           : proto::transform<
229                 function<
230                     A0 , A1
231                     , void , void , void , void , void , void , void , void
232                 >
233               , int
234             >
235         {
236             typedef proto::expr<proto::tag::function, list2<A0 , A1>, 2> type;
237             typedef proto::basic_expr<proto::tag::function, list2<A0 , A1>, 2> proto_grammar;
238             template<typename Expr, typename State, typename Data>
239             struct impl
240               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
241             {};
242 
243             typedef proto::tag::function proto_tag;
244             typedef A0 proto_child0; typedef A1 proto_child1;
245             typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9;
246         };
247 
248 
249 
250 
251 
252 
253 
254 
255         template<typename Tag , typename A0 , typename A1>
256         struct nary_expr
257         <
258             Tag
259             , A0 , A1
260             , void , void , void , void , void , void , void , void
261         >
262           : proto::transform<
263                 nary_expr<
264                     Tag
265                     , A0 , A1
266                     , void , void , void , void , void , void , void , void
267                 >
268               , int
269             >
270         {
271             typedef proto::expr<Tag, list2<A0 , A1>, 2> type;
272             typedef proto::basic_expr<Tag, list2<A0 , A1>, 2> proto_grammar;
273             template<typename Expr, typename State, typename Data>
274             struct impl
275               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
276             {};
277 
278             typedef Tag proto_tag;
279             typedef A0 proto_child0; typedef A1 proto_child1;
280             typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9;
281         };
282         namespace detail
283         {
284             template<
285                 template<typename , typename> class T
286               , typename A0 , typename A1
287             >
288             struct is_callable_<T<A0 , A1> BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)>
289               : is_same<A1, callable>
290             {};
291         }
292         namespace result_of
293         {
294 
295 
296 
297 
298 
299 
300             template<typename Expr>
301             struct child_c<Expr, 2>
302             {
303 
304                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
305 
306 
307                 typedef typename Expr::proto_child2 value_type;
308 
309 
310 
311 
312 
313                 typedef typename detail::expr_traits<typename Expr::proto_child2>::value_type type;
314             };
315             template<typename Expr>
316             struct child_c<Expr &, 2>
317             {
318 
319                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
320 
321 
322                 typedef typename Expr::proto_child2 value_type;
323 
324 
325 
326 
327 
328                 typedef typename detail::expr_traits<typename Expr::proto_child2>::reference type;
329 
330 
331                 BOOST_FORCEINLINE
callresult_of::child_c332                 static type call(Expr &e)
333                 {
334                     return e.proto_base().child2;
335                 }
336             };
337             template<typename Expr>
338             struct child_c<Expr const &, 2>
339             {
340 
341                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
342 
343 
344                 typedef typename Expr::proto_child2 value_type;
345 
346 
347 
348 
349 
350                 typedef typename detail::expr_traits<typename Expr::proto_child2>::const_reference type;
351 
352 
353                 BOOST_FORCEINLINE
callresult_of::child_c354                 static type call(Expr const &e)
355                 {
356                     return e.proto_base().child2;
357                 }
358             };
359         }
360 
361 
362 
363 
364         template<typename A0 , typename A1 , typename A2>
365         struct function
366         <
367             A0 , A1 , A2
368             , void , void , void , void , void , void , void
369         >
370           : proto::transform<
371                 function<
372                     A0 , A1 , A2
373                     , void , void , void , void , void , void , void
374                 >
375               , int
376             >
377         {
378             typedef proto::expr<proto::tag::function, list3<A0 , A1 , A2>, 3> type;
379             typedef proto::basic_expr<proto::tag::function, list3<A0 , A1 , A2>, 3> proto_grammar;
380             template<typename Expr, typename State, typename Data>
381             struct impl
382               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
383             {};
384 
385             typedef proto::tag::function proto_tag;
386             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2;
387             typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9;
388         };
389 
390 
391 
392 
393 
394 
395 
396 
397         template<typename Tag , typename A0 , typename A1 , typename A2>
398         struct nary_expr
399         <
400             Tag
401             , A0 , A1 , A2
402             , void , void , void , void , void , void , void
403         >
404           : proto::transform<
405                 nary_expr<
406                     Tag
407                     , A0 , A1 , A2
408                     , void , void , void , void , void , void , void
409                 >
410               , int
411             >
412         {
413             typedef proto::expr<Tag, list3<A0 , A1 , A2>, 3> type;
414             typedef proto::basic_expr<Tag, list3<A0 , A1 , A2>, 3> proto_grammar;
415             template<typename Expr, typename State, typename Data>
416             struct impl
417               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
418             {};
419 
420             typedef Tag proto_tag;
421             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2;
422             typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9;
423         };
424         namespace detail
425         {
426             template<
427                 template<typename , typename , typename> class T
428               , typename A0 , typename A1 , typename A2
429             >
430             struct is_callable_<T<A0 , A1 , A2> BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)>
431               : is_same<A2, callable>
432             {};
433         }
434         namespace result_of
435         {
436 
437 
438 
439 
440 
441 
442             template<typename Expr>
443             struct child_c<Expr, 3>
444             {
445 
446                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
447 
448 
449                 typedef typename Expr::proto_child3 value_type;
450 
451 
452 
453 
454 
455                 typedef typename detail::expr_traits<typename Expr::proto_child3>::value_type type;
456             };
457             template<typename Expr>
458             struct child_c<Expr &, 3>
459             {
460 
461                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
462 
463 
464                 typedef typename Expr::proto_child3 value_type;
465 
466 
467 
468 
469 
470                 typedef typename detail::expr_traits<typename Expr::proto_child3>::reference type;
471 
472 
473                 BOOST_FORCEINLINE
callresult_of::child_c474                 static type call(Expr &e)
475                 {
476                     return e.proto_base().child3;
477                 }
478             };
479             template<typename Expr>
480             struct child_c<Expr const &, 3>
481             {
482 
483                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
484 
485 
486                 typedef typename Expr::proto_child3 value_type;
487 
488 
489 
490 
491 
492                 typedef typename detail::expr_traits<typename Expr::proto_child3>::const_reference type;
493 
494 
495                 BOOST_FORCEINLINE
callresult_of::child_c496                 static type call(Expr const &e)
497                 {
498                     return e.proto_base().child3;
499                 }
500             };
501         }
502 
503 
504 
505 
506         template<typename A0 , typename A1 , typename A2 , typename A3>
507         struct function
508         <
509             A0 , A1 , A2 , A3
510             , void , void , void , void , void , void
511         >
512           : proto::transform<
513                 function<
514                     A0 , A1 , A2 , A3
515                     , void , void , void , void , void , void
516                 >
517               , int
518             >
519         {
520             typedef proto::expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> type;
521             typedef proto::basic_expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> proto_grammar;
522             template<typename Expr, typename State, typename Data>
523             struct impl
524               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
525             {};
526 
527             typedef proto::tag::function proto_tag;
528             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3;
529             typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9;
530         };
531 
532 
533 
534 
535 
536 
537 
538 
539         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
540         struct nary_expr
541         <
542             Tag
543             , A0 , A1 , A2 , A3
544             , void , void , void , void , void , void
545         >
546           : proto::transform<
547                 nary_expr<
548                     Tag
549                     , A0 , A1 , A2 , A3
550                     , void , void , void , void , void , void
551                 >
552               , int
553             >
554         {
555             typedef proto::expr<Tag, list4<A0 , A1 , A2 , A3>, 4> type;
556             typedef proto::basic_expr<Tag, list4<A0 , A1 , A2 , A3>, 4> proto_grammar;
557             template<typename Expr, typename State, typename Data>
558             struct impl
559               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
560             {};
561 
562             typedef Tag proto_tag;
563             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3;
564             typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9;
565         };
566         namespace detail
567         {
568             template<
569                 template<typename , typename , typename , typename> class T
570               , typename A0 , typename A1 , typename A2 , typename A3
571             >
572             struct is_callable_<T<A0 , A1 , A2 , A3> BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)>
573               : is_same<A3, callable>
574             {};
575         }
576         namespace result_of
577         {
578 
579 
580 
581 
582 
583 
584             template<typename Expr>
585             struct child_c<Expr, 4>
586             {
587 
588                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
589 
590 
591                 typedef typename Expr::proto_child4 value_type;
592 
593 
594 
595 
596 
597                 typedef typename detail::expr_traits<typename Expr::proto_child4>::value_type type;
598             };
599             template<typename Expr>
600             struct child_c<Expr &, 4>
601             {
602 
603                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
604 
605 
606                 typedef typename Expr::proto_child4 value_type;
607 
608 
609 
610 
611 
612                 typedef typename detail::expr_traits<typename Expr::proto_child4>::reference type;
613 
614 
615                 BOOST_FORCEINLINE
callresult_of::child_c616                 static type call(Expr &e)
617                 {
618                     return e.proto_base().child4;
619                 }
620             };
621             template<typename Expr>
622             struct child_c<Expr const &, 4>
623             {
624 
625                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
626 
627 
628                 typedef typename Expr::proto_child4 value_type;
629 
630 
631 
632 
633 
634                 typedef typename detail::expr_traits<typename Expr::proto_child4>::const_reference type;
635 
636 
637                 BOOST_FORCEINLINE
callresult_of::child_c638                 static type call(Expr const &e)
639                 {
640                     return e.proto_base().child4;
641                 }
642             };
643         }
644 
645 
646 
647 
648         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
649         struct function
650         <
651             A0 , A1 , A2 , A3 , A4
652             , void , void , void , void , void
653         >
654           : proto::transform<
655                 function<
656                     A0 , A1 , A2 , A3 , A4
657                     , void , void , void , void , void
658                 >
659               , int
660             >
661         {
662             typedef proto::expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> type;
663             typedef proto::basic_expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar;
664             template<typename Expr, typename State, typename Data>
665             struct impl
666               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
667             {};
668 
669             typedef proto::tag::function proto_tag;
670             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4;
671             typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9;
672         };
673 
674 
675 
676 
677 
678 
679 
680 
681         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
682         struct nary_expr
683         <
684             Tag
685             , A0 , A1 , A2 , A3 , A4
686             , void , void , void , void , void
687         >
688           : proto::transform<
689                 nary_expr<
690                     Tag
691                     , A0 , A1 , A2 , A3 , A4
692                     , void , void , void , void , void
693                 >
694               , int
695             >
696         {
697             typedef proto::expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> type;
698             typedef proto::basic_expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar;
699             template<typename Expr, typename State, typename Data>
700             struct impl
701               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
702             {};
703 
704             typedef Tag proto_tag;
705             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4;
706             typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9;
707         };
708         namespace detail
709         {
710             template<
711                 template<typename , typename , typename , typename , typename> class T
712               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
713             >
714             struct is_callable_<T<A0 , A1 , A2 , A3 , A4> BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)>
715               : is_same<A4, callable>
716             {};
717         }
718         namespace result_of
719         {
720 
721 
722 
723 
724 
725 
726             template<typename Expr>
727             struct child_c<Expr, 5>
728             {
729 
730                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
731 
732 
733                 typedef typename Expr::proto_child5 value_type;
734 
735 
736 
737 
738 
739                 typedef typename detail::expr_traits<typename Expr::proto_child5>::value_type type;
740             };
741             template<typename Expr>
742             struct child_c<Expr &, 5>
743             {
744 
745                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
746 
747 
748                 typedef typename Expr::proto_child5 value_type;
749 
750 
751 
752 
753 
754                 typedef typename detail::expr_traits<typename Expr::proto_child5>::reference type;
755 
756 
757                 BOOST_FORCEINLINE
callresult_of::child_c758                 static type call(Expr &e)
759                 {
760                     return e.proto_base().child5;
761                 }
762             };
763             template<typename Expr>
764             struct child_c<Expr const &, 5>
765             {
766 
767                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
768 
769 
770                 typedef typename Expr::proto_child5 value_type;
771 
772 
773 
774 
775 
776                 typedef typename detail::expr_traits<typename Expr::proto_child5>::const_reference type;
777 
778 
779                 BOOST_FORCEINLINE
callresult_of::child_c780                 static type call(Expr const &e)
781                 {
782                     return e.proto_base().child5;
783                 }
784             };
785         }
786 
787 
788 
789 
790         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
791         struct function
792         <
793             A0 , A1 , A2 , A3 , A4 , A5
794             , void , void , void , void
795         >
796           : proto::transform<
797                 function<
798                     A0 , A1 , A2 , A3 , A4 , A5
799                     , void , void , void , void
800                 >
801               , int
802             >
803         {
804             typedef proto::expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type;
805             typedef proto::basic_expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar;
806             template<typename Expr, typename State, typename Data>
807             struct impl
808               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
809             {};
810 
811             typedef proto::tag::function proto_tag;
812             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5;
813             typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9;
814         };
815 
816 
817 
818 
819 
820 
821 
822 
823         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
824         struct nary_expr
825         <
826             Tag
827             , A0 , A1 , A2 , A3 , A4 , A5
828             , void , void , void , void
829         >
830           : proto::transform<
831                 nary_expr<
832                     Tag
833                     , A0 , A1 , A2 , A3 , A4 , A5
834                     , void , void , void , void
835                 >
836               , int
837             >
838         {
839             typedef proto::expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type;
840             typedef proto::basic_expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar;
841             template<typename Expr, typename State, typename Data>
842             struct impl
843               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
844             {};
845 
846             typedef Tag proto_tag;
847             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5;
848             typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9;
849         };
850         namespace detail
851         {
852             template<
853                 template<typename , typename , typename , typename , typename , typename> class T
854               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
855             >
856             struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5> BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)>
857               : is_same<A5, callable>
858             {};
859         }
860         namespace result_of
861         {
862 
863 
864 
865 
866 
867 
868             template<typename Expr>
869             struct child_c<Expr, 6>
870             {
871 
872                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
873 
874 
875                 typedef typename Expr::proto_child6 value_type;
876 
877 
878 
879 
880 
881                 typedef typename detail::expr_traits<typename Expr::proto_child6>::value_type type;
882             };
883             template<typename Expr>
884             struct child_c<Expr &, 6>
885             {
886 
887                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
888 
889 
890                 typedef typename Expr::proto_child6 value_type;
891 
892 
893 
894 
895 
896                 typedef typename detail::expr_traits<typename Expr::proto_child6>::reference type;
897 
898 
899                 BOOST_FORCEINLINE
callresult_of::child_c900                 static type call(Expr &e)
901                 {
902                     return e.proto_base().child6;
903                 }
904             };
905             template<typename Expr>
906             struct child_c<Expr const &, 6>
907             {
908 
909                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
910 
911 
912                 typedef typename Expr::proto_child6 value_type;
913 
914 
915 
916 
917 
918                 typedef typename detail::expr_traits<typename Expr::proto_child6>::const_reference type;
919 
920 
921                 BOOST_FORCEINLINE
callresult_of::child_c922                 static type call(Expr const &e)
923                 {
924                     return e.proto_base().child6;
925                 }
926             };
927         }
928 
929 
930 
931 
932         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
933         struct function
934         <
935             A0 , A1 , A2 , A3 , A4 , A5 , A6
936             , void , void , void
937         >
938           : proto::transform<
939                 function<
940                     A0 , A1 , A2 , A3 , A4 , A5 , A6
941                     , void , void , void
942                 >
943               , int
944             >
945         {
946             typedef proto::expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type;
947             typedef proto::basic_expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar;
948             template<typename Expr, typename State, typename Data>
949             struct impl
950               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
951             {};
952 
953             typedef proto::tag::function proto_tag;
954             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6;
955             typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9;
956         };
957 
958 
959 
960 
961 
962 
963 
964 
965         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
966         struct nary_expr
967         <
968             Tag
969             , A0 , A1 , A2 , A3 , A4 , A5 , A6
970             , void , void , void
971         >
972           : proto::transform<
973                 nary_expr<
974                     Tag
975                     , A0 , A1 , A2 , A3 , A4 , A5 , A6
976                     , void , void , void
977                 >
978               , int
979             >
980         {
981             typedef proto::expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type;
982             typedef proto::basic_expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar;
983             template<typename Expr, typename State, typename Data>
984             struct impl
985               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
986             {};
987 
988             typedef Tag proto_tag;
989             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6;
990             typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9;
991         };
992         namespace detail
993         {
994             template<
995                 template<typename , typename , typename , typename , typename , typename , typename> class T
996               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
997             >
998             struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6> BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)>
999               : is_same<A6, callable>
1000             {};
1001         }
1002         namespace result_of
1003         {
1004 
1005 
1006 
1007 
1008 
1009 
1010             template<typename Expr>
1011             struct child_c<Expr, 7>
1012             {
1013 
1014                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1015 
1016 
1017                 typedef typename Expr::proto_child7 value_type;
1018 
1019 
1020 
1021 
1022 
1023                 typedef typename detail::expr_traits<typename Expr::proto_child7>::value_type type;
1024             };
1025             template<typename Expr>
1026             struct child_c<Expr &, 7>
1027             {
1028 
1029                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1030 
1031 
1032                 typedef typename Expr::proto_child7 value_type;
1033 
1034 
1035 
1036 
1037 
1038                 typedef typename detail::expr_traits<typename Expr::proto_child7>::reference type;
1039 
1040 
1041                 BOOST_FORCEINLINE
callresult_of::child_c1042                 static type call(Expr &e)
1043                 {
1044                     return e.proto_base().child7;
1045                 }
1046             };
1047             template<typename Expr>
1048             struct child_c<Expr const &, 7>
1049             {
1050 
1051                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1052 
1053 
1054                 typedef typename Expr::proto_child7 value_type;
1055 
1056 
1057 
1058 
1059 
1060                 typedef typename detail::expr_traits<typename Expr::proto_child7>::const_reference type;
1061 
1062 
1063                 BOOST_FORCEINLINE
callresult_of::child_c1064                 static type call(Expr const &e)
1065                 {
1066                     return e.proto_base().child7;
1067                 }
1068             };
1069         }
1070 
1071 
1072 
1073 
1074         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1075         struct function
1076         <
1077             A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
1078             , void , void
1079         >
1080           : proto::transform<
1081                 function<
1082                     A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
1083                     , void , void
1084                 >
1085               , int
1086             >
1087         {
1088             typedef proto::expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type;
1089             typedef proto::basic_expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar;
1090             template<typename Expr, typename State, typename Data>
1091             struct impl
1092               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
1093             {};
1094 
1095             typedef proto::tag::function proto_tag;
1096             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7;
1097             typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9;
1098         };
1099 
1100 
1101 
1102 
1103 
1104 
1105 
1106 
1107         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1108         struct nary_expr
1109         <
1110             Tag
1111             , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
1112             , void , void
1113         >
1114           : proto::transform<
1115                 nary_expr<
1116                     Tag
1117                     , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
1118                     , void , void
1119                 >
1120               , int
1121             >
1122         {
1123             typedef proto::expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type;
1124             typedef proto::basic_expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar;
1125             template<typename Expr, typename State, typename Data>
1126             struct impl
1127               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
1128             {};
1129 
1130             typedef Tag proto_tag;
1131             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7;
1132             typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9;
1133         };
1134         namespace detail
1135         {
1136             template<
1137                 template<typename , typename , typename , typename , typename , typename , typename , typename> class T
1138               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
1139             >
1140             struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)>
1141               : is_same<A7, callable>
1142             {};
1143         }
1144         namespace result_of
1145         {
1146 
1147 
1148 
1149 
1150 
1151 
1152             template<typename Expr>
1153             struct child_c<Expr, 8>
1154             {
1155 
1156                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1157 
1158 
1159                 typedef typename Expr::proto_child8 value_type;
1160 
1161 
1162 
1163 
1164 
1165                 typedef typename detail::expr_traits<typename Expr::proto_child8>::value_type type;
1166             };
1167             template<typename Expr>
1168             struct child_c<Expr &, 8>
1169             {
1170 
1171                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1172 
1173 
1174                 typedef typename Expr::proto_child8 value_type;
1175 
1176 
1177 
1178 
1179 
1180                 typedef typename detail::expr_traits<typename Expr::proto_child8>::reference type;
1181 
1182 
1183                 BOOST_FORCEINLINE
callresult_of::child_c1184                 static type call(Expr &e)
1185                 {
1186                     return e.proto_base().child8;
1187                 }
1188             };
1189             template<typename Expr>
1190             struct child_c<Expr const &, 8>
1191             {
1192 
1193                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1194 
1195 
1196                 typedef typename Expr::proto_child8 value_type;
1197 
1198 
1199 
1200 
1201 
1202                 typedef typename detail::expr_traits<typename Expr::proto_child8>::const_reference type;
1203 
1204 
1205                 BOOST_FORCEINLINE
callresult_of::child_c1206                 static type call(Expr const &e)
1207                 {
1208                     return e.proto_base().child8;
1209                 }
1210             };
1211         }
1212 
1213 
1214 
1215 
1216         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1217         struct function
1218         <
1219             A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
1220             , void
1221         >
1222           : proto::transform<
1223                 function<
1224                     A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
1225                     , void
1226                 >
1227               , int
1228             >
1229         {
1230             typedef proto::expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type;
1231             typedef proto::basic_expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar;
1232             template<typename Expr, typename State, typename Data>
1233             struct impl
1234               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
1235             {};
1236 
1237             typedef proto::tag::function proto_tag;
1238             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8;
1239             typedef detail::if_vararg<A8> proto_child9;
1240         };
1241 
1242 
1243 
1244 
1245 
1246 
1247 
1248 
1249         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1250         struct nary_expr
1251         <
1252             Tag
1253             , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
1254             , void
1255         >
1256           : proto::transform<
1257                 nary_expr<
1258                     Tag
1259                     , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
1260                     , void
1261                 >
1262               , int
1263             >
1264         {
1265             typedef proto::expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type;
1266             typedef proto::basic_expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar;
1267             template<typename Expr, typename State, typename Data>
1268             struct impl
1269               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
1270             {};
1271 
1272             typedef Tag proto_tag;
1273             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8;
1274             typedef detail::if_vararg<A8> proto_child9;
1275         };
1276         namespace detail
1277         {
1278             template<
1279                 template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
1280               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
1281             >
1282             struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)>
1283               : is_same<A8, callable>
1284             {};
1285         }
1286         namespace result_of
1287         {
1288 
1289 
1290 
1291 
1292 
1293 
1294             template<typename Expr>
1295             struct child_c<Expr, 9>
1296             {
1297 
1298                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1299 
1300 
1301                 typedef typename Expr::proto_child9 value_type;
1302 
1303 
1304 
1305 
1306 
1307                 typedef typename detail::expr_traits<typename Expr::proto_child9>::value_type type;
1308             };
1309             template<typename Expr>
1310             struct child_c<Expr &, 9>
1311             {
1312 
1313                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1314 
1315 
1316                 typedef typename Expr::proto_child9 value_type;
1317 
1318 
1319 
1320 
1321 
1322                 typedef typename detail::expr_traits<typename Expr::proto_child9>::reference type;
1323 
1324 
1325                 BOOST_FORCEINLINE
callresult_of::child_c1326                 static type call(Expr &e)
1327                 {
1328                     return e.proto_base().child9;
1329                 }
1330             };
1331             template<typename Expr>
1332             struct child_c<Expr const &, 9>
1333             {
1334 
1335                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1336 
1337 
1338                 typedef typename Expr::proto_child9 value_type;
1339 
1340 
1341 
1342 
1343 
1344                 typedef typename detail::expr_traits<typename Expr::proto_child9>::const_reference type;
1345 
1346 
1347                 BOOST_FORCEINLINE
callresult_of::child_c1348                 static type call(Expr const &e)
1349                 {
1350                     return e.proto_base().child9;
1351                 }
1352             };
1353         }
1354 
1355 
1356 
1357 
1358         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1359         struct function
1360           : proto::transform<
1361                 function<
1362                     A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
1363 
1364                 >
1365               , int
1366             >
1367         {
1368             typedef proto::expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type;
1369             typedef proto::basic_expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar;
1370             template<typename Expr, typename State, typename Data>
1371             struct impl
1372               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
1373             {};
1374 
1375             typedef proto::tag::function proto_tag;
1376             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9;
1377 
1378         };
1379 
1380 
1381 
1382 
1383 
1384 
1385 
1386 
1387         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1388         struct nary_expr
1389           : proto::transform<
1390                 nary_expr<
1391                     Tag
1392                     , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
1393 
1394                 >
1395               , int
1396             >
1397         {
1398             typedef proto::expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type;
1399             typedef proto::basic_expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar;
1400             template<typename Expr, typename State, typename Data>
1401             struct impl
1402               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
1403             {};
1404 
1405             typedef Tag proto_tag;
1406             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9;
1407 
1408         };
1409         namespace detail
1410         {
1411             template<
1412                 template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
1413               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
1414             >
1415             struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)>
1416               : is_same<A9, callable>
1417             {};
1418         }
1419         namespace result_of
1420         {
1421 
1422 
1423 
1424 
1425 
1426 
1427             template<typename Expr>
1428             struct child_c<Expr, 10>
1429             {
1430 
1431                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1432 
1433 
1434                 typedef typename Expr::proto_child10 value_type;
1435 
1436 
1437 
1438 
1439 
1440                 typedef typename detail::expr_traits<typename Expr::proto_child10>::value_type type;
1441             };
1442             template<typename Expr>
1443             struct child_c<Expr &, 10>
1444             {
1445 
1446                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1447 
1448 
1449                 typedef typename Expr::proto_child10 value_type;
1450 
1451 
1452 
1453 
1454 
1455                 typedef typename detail::expr_traits<typename Expr::proto_child10>::reference type;
1456 
1457 
1458                 BOOST_FORCEINLINE
callresult_of::child_c1459                 static type call(Expr &e)
1460                 {
1461                     return e.proto_base().child10;
1462                 }
1463             };
1464             template<typename Expr>
1465             struct child_c<Expr const &, 10>
1466             {
1467 
1468                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
1469 
1470 
1471                 typedef typename Expr::proto_child10 value_type;
1472 
1473 
1474 
1475 
1476 
1477                 typedef typename detail::expr_traits<typename Expr::proto_child10>::const_reference type;
1478 
1479 
1480                 BOOST_FORCEINLINE
callresult_of::child_c1481                 static type call(Expr const &e)
1482                 {
1483                     return e.proto_base().child10;
1484                 }
1485             };
1486         }
1487