inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/proto/detail/preprocessed/traits.hpp

   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         }