Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/proto/detail/preprocessed/traits.hpp @ 16:2665513ce2d3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add boost headers
author Chris Cannam
date Tue, 05 Aug 2014 11:11:38 +0100
parents
children
comparison
equal deleted inserted replaced
15:663ca0da4350 16:2665513ce2d3
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
48 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
70 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
190 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
212 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
332 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
354 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
474 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
496 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
616 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
638 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
758 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
780 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
900 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
922 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
1042 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
1064 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
1184 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
1206 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
1326 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
1348 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
1459 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
1481 static type call(Expr const &e)
1482 {
1483 return e.proto_base().child10;
1484 }
1485 };
1486 }