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