detail/preprocessed/traits.hpp

0001     ///////////////////////////////////////////////////////////////////////////////
0002     /// \file traits.hpp
0003     /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c
0004     //
0005     //  Copyright 2008 Eric Niebler. Distributed under the Boost
0006     //  Software License, Version 1.0. (See accompanying file
0007     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008         namespace result_of
0009         {
0010
0011
0012
0013
0014
0015
0016             template<typename Expr>
0017             struct child_c<Expr, 0>
0018             {
0019
0020                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0021
0022
0023                 typedef typename Expr::proto_child0 value_type;
0024
0025
0026
0027
0028
0029                 typedef typename detail::expr_traits<typename Expr::proto_child0>::value_type type;
0030             };
0031             template<typename Expr>
0032             struct child_c<Expr &, 0>
0033             {
0034
0035                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0036
0037
0038                 typedef typename Expr::proto_child0 value_type;
0039
0040
0041
0042
0043
0044                 typedef typename detail::expr_traits<typename Expr::proto_child0>::reference type;
0045
0046
0047                 BOOST_FORCEINLINE
0048                 static type call(Expr &e)
0049                 {
0050                     return e.proto_base().child0;
0051                 }
0052             };
0053             template<typename Expr>
0054             struct child_c<Expr const &, 0>
0055             {
0056
0057                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0058
0059
0060                 typedef typename Expr::proto_child0 value_type;
0061
0062
0063
0064
0065
0066                 typedef typename detail::expr_traits<typename Expr::proto_child0>::const_reference type;
0067
0068
0069                 BOOST_FORCEINLINE
0070                 static type call(Expr const &e)
0071                 {
0072                     return e.proto_base().child0;
0073                 }
0074             };
0075         }
0076
0077
0078
0079
0080         template<typename A0>
0081         struct function
0082         <
0083             A0
0084             , void , void , void , void , void , void , void , void , void
0085         >
0086           : proto::transform<
0087                 function<
0088                     A0
0089                     , void , void , void , void , void , void , void , void , void
0090                 >
0091               , int
0092             >
0093         {
0094             typedef proto::expr<proto::tag::function, list1<A0>, 1> type;
0095             typedef proto::basic_expr<proto::tag::function, list1<A0>, 1> proto_grammar;
0096             template<typename Expr, typename State, typename Data>
0097             struct impl
0098               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
0099             {};
0100
0101             typedef proto::tag::function proto_tag;
0102             typedef A0 proto_child0;
0103             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;
0104         };
0105
0106
0107
0108
0109
0110
0111
0112
0113         template<typename Tag , typename A0>
0114         struct nary_expr
0115         <
0116             Tag
0117             , A0
0118             , void , void , void , void , void , void , void , void , void
0119         >
0120           : proto::transform<
0121                 nary_expr<
0122                     Tag
0123                     , A0
0124                     , void , void , void , void , void , void , void , void , void
0125                 >
0126               , int
0127             >
0128         {
0129             typedef proto::expr<Tag, list1<A0>, 1> type;
0130             typedef proto::basic_expr<Tag, list1<A0>, 1> proto_grammar;
0131             template<typename Expr, typename State, typename Data>
0132             struct impl
0133               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
0134             {};
0135
0136             typedef Tag proto_tag;
0137             typedef A0 proto_child0;
0138             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;
0139         };
0140         namespace detail
0141         {
0142             template<
0143                 template<typename> class T
0144               , typename A0
0145             >
0146             struct is_callable_<T<A0> BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)>
0147               : is_same<A0, callable>
0148             {};
0149         }
0150         namespace result_of
0151         {
0152
0153
0154
0155
0156
0157
0158             template<typename Expr>
0159             struct child_c<Expr, 1>
0160             {
0161
0162                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0163
0164
0165                 typedef typename Expr::proto_child1 value_type;
0166
0167
0168
0169
0170
0171                 typedef typename detail::expr_traits<typename Expr::proto_child1>::value_type type;
0172             };
0173             template<typename Expr>
0174             struct child_c<Expr &, 1>
0175             {
0176
0177                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0178
0179
0180                 typedef typename Expr::proto_child1 value_type;
0181
0182
0183
0184
0185
0186                 typedef typename detail::expr_traits<typename Expr::proto_child1>::reference type;
0187
0188
0189                 BOOST_FORCEINLINE
0190                 static type call(Expr &e)
0191                 {
0192                     return e.proto_base().child1;
0193                 }
0194             };
0195             template<typename Expr>
0196             struct child_c<Expr const &, 1>
0197             {
0198
0199                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0200
0201
0202                 typedef typename Expr::proto_child1 value_type;
0203
0204
0205
0206
0207
0208                 typedef typename detail::expr_traits<typename Expr::proto_child1>::const_reference type;
0209
0210
0211                 BOOST_FORCEINLINE
0212                 static type call(Expr const &e)
0213                 {
0214                     return e.proto_base().child1;
0215                 }
0216             };
0217         }
0218
0219
0220
0221
0222         template<typename A0 , typename A1>
0223         struct function
0224         <
0225             A0 , A1
0226             , void , void , void , void , void , void , void , void
0227         >
0228           : proto::transform<
0229                 function<
0230                     A0 , A1
0231                     , void , void , void , void , void , void , void , void
0232                 >
0233               , int
0234             >
0235         {
0236             typedef proto::expr<proto::tag::function, list2<A0 , A1>, 2> type;
0237             typedef proto::basic_expr<proto::tag::function, list2<A0 , A1>, 2> proto_grammar;
0238             template<typename Expr, typename State, typename Data>
0239             struct impl
0240               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
0241             {};
0242
0243             typedef proto::tag::function proto_tag;
0244             typedef A0 proto_child0; typedef A1 proto_child1;
0245             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;
0246         };
0247
0248
0249
0250
0251
0252
0253
0254
0255         template<typename Tag , typename A0 , typename A1>
0256         struct nary_expr
0257         <
0258             Tag
0259             , A0 , A1
0260             , void , void , void , void , void , void , void , void
0261         >
0262           : proto::transform<
0263                 nary_expr<
0264                     Tag
0265                     , A0 , A1
0266                     , void , void , void , void , void , void , void , void
0267                 >
0268               , int
0269             >
0270         {
0271             typedef proto::expr<Tag, list2<A0 , A1>, 2> type;
0272             typedef proto::basic_expr<Tag, list2<A0 , A1>, 2> proto_grammar;
0273             template<typename Expr, typename State, typename Data>
0274             struct impl
0275               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
0276             {};
0277
0278             typedef Tag proto_tag;
0279             typedef A0 proto_child0; typedef A1 proto_child1;
0280             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;
0281         };
0282         namespace detail
0283         {
0284             template<
0285                 template<typename , typename> class T
0286               , typename A0 , typename A1
0287             >
0288             struct is_callable_<T<A0 , A1> BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)>
0289               : is_same<A1, callable>
0290             {};
0291         }
0292         namespace result_of
0293         {
0294
0295
0296
0297
0298
0299
0300             template<typename Expr>
0301             struct child_c<Expr, 2>
0302             {
0303
0304                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0305
0306
0307                 typedef typename Expr::proto_child2 value_type;
0308
0309
0310
0311
0312
0313                 typedef typename detail::expr_traits<typename Expr::proto_child2>::value_type type;
0314             };
0315             template<typename Expr>
0316             struct child_c<Expr &, 2>
0317             {
0318
0319                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0320
0321
0322                 typedef typename Expr::proto_child2 value_type;
0323
0324
0325
0326
0327
0328                 typedef typename detail::expr_traits<typename Expr::proto_child2>::reference type;
0329
0330
0331                 BOOST_FORCEINLINE
0332                 static type call(Expr &e)
0333                 {
0334                     return e.proto_base().child2;
0335                 }
0336             };
0337             template<typename Expr>
0338             struct child_c<Expr const &, 2>
0339             {
0340
0341                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0342
0343
0344                 typedef typename Expr::proto_child2 value_type;
0345
0346
0347
0348
0349
0350                 typedef typename detail::expr_traits<typename Expr::proto_child2>::const_reference type;
0351
0352
0353                 BOOST_FORCEINLINE
0354                 static type call(Expr const &e)
0355                 {
0356                     return e.proto_base().child2;
0357                 }
0358             };
0359         }
0360
0361
0362
0363
0364         template<typename A0 , typename A1 , typename A2>
0365         struct function
0366         <
0367             A0 , A1 , A2
0368             , void , void , void , void , void , void , void
0369         >
0370           : proto::transform<
0371                 function<
0372                     A0 , A1 , A2
0373                     , void , void , void , void , void , void , void
0374                 >
0375               , int
0376             >
0377         {
0378             typedef proto::expr<proto::tag::function, list3<A0 , A1 , A2>, 3> type;
0379             typedef proto::basic_expr<proto::tag::function, list3<A0 , A1 , A2>, 3> proto_grammar;
0380             template<typename Expr, typename State, typename Data>
0381             struct impl
0382               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
0383             {};
0384
0385             typedef proto::tag::function proto_tag;
0386             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2;
0387             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;
0388         };
0389
0390
0391
0392
0393
0394
0395
0396
0397         template<typename Tag , typename A0 , typename A1 , typename A2>
0398         struct nary_expr
0399         <
0400             Tag
0401             , A0 , A1 , A2
0402             , void , void , void , void , void , void , void
0403         >
0404           : proto::transform<
0405                 nary_expr<
0406                     Tag
0407                     , A0 , A1 , A2
0408                     , void , void , void , void , void , void , void
0409                 >
0410               , int
0411             >
0412         {
0413             typedef proto::expr<Tag, list3<A0 , A1 , A2>, 3> type;
0414             typedef proto::basic_expr<Tag, list3<A0 , A1 , A2>, 3> proto_grammar;
0415             template<typename Expr, typename State, typename Data>
0416             struct impl
0417               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
0418             {};
0419
0420             typedef Tag proto_tag;
0421             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2;
0422             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;
0423         };
0424         namespace detail
0425         {
0426             template<
0427                 template<typename , typename , typename> class T
0428               , typename A0 , typename A1 , typename A2
0429             >
0430             struct is_callable_<T<A0 , A1 , A2> BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)>
0431               : is_same<A2, callable>
0432             {};
0433         }
0434         namespace result_of
0435         {
0436
0437
0438
0439
0440
0441
0442             template<typename Expr>
0443             struct child_c<Expr, 3>
0444             {
0445
0446                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0447
0448
0449                 typedef typename Expr::proto_child3 value_type;
0450
0451
0452
0453
0454
0455                 typedef typename detail::expr_traits<typename Expr::proto_child3>::value_type type;
0456             };
0457             template<typename Expr>
0458             struct child_c<Expr &, 3>
0459             {
0460
0461                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0462
0463
0464                 typedef typename Expr::proto_child3 value_type;
0465
0466
0467
0468
0469
0470                 typedef typename detail::expr_traits<typename Expr::proto_child3>::reference type;
0471
0472
0473                 BOOST_FORCEINLINE
0474                 static type call(Expr &e)
0475                 {
0476                     return e.proto_base().child3;
0477                 }
0478             };
0479             template<typename Expr>
0480             struct child_c<Expr const &, 3>
0481             {
0482
0483                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0484
0485
0486                 typedef typename Expr::proto_child3 value_type;
0487
0488
0489
0490
0491
0492                 typedef typename detail::expr_traits<typename Expr::proto_child3>::const_reference type;
0493
0494
0495                 BOOST_FORCEINLINE
0496                 static type call(Expr const &e)
0497                 {
0498                     return e.proto_base().child3;
0499                 }
0500             };
0501         }
0502
0503
0504
0505
0506         template<typename A0 , typename A1 , typename A2 , typename A3>
0507         struct function
0508         <
0509             A0 , A1 , A2 , A3
0510             , void , void , void , void , void , void
0511         >
0512           : proto::transform<
0513                 function<
0514                     A0 , A1 , A2 , A3
0515                     , void , void , void , void , void , void
0516                 >
0517               , int
0518             >
0519         {
0520             typedef proto::expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> type;
0521             typedef proto::basic_expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> proto_grammar;
0522             template<typename Expr, typename State, typename Data>
0523             struct impl
0524               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
0525             {};
0526
0527             typedef proto::tag::function proto_tag;
0528             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3;
0529             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;
0530         };
0531
0532
0533
0534
0535
0536
0537
0538
0539         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
0540         struct nary_expr
0541         <
0542             Tag
0543             , A0 , A1 , A2 , A3
0544             , void , void , void , void , void , void
0545         >
0546           : proto::transform<
0547                 nary_expr<
0548                     Tag
0549                     , A0 , A1 , A2 , A3
0550                     , void , void , void , void , void , void
0551                 >
0552               , int
0553             >
0554         {
0555             typedef proto::expr<Tag, list4<A0 , A1 , A2 , A3>, 4> type;
0556             typedef proto::basic_expr<Tag, list4<A0 , A1 , A2 , A3>, 4> proto_grammar;
0557             template<typename Expr, typename State, typename Data>
0558             struct impl
0559               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
0560             {};
0561
0562             typedef Tag proto_tag;
0563             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3;
0564             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;
0565         };
0566         namespace detail
0567         {
0568             template<
0569                 template<typename , typename , typename , typename> class T
0570               , typename A0 , typename A1 , typename A2 , typename A3
0571             >
0572             struct is_callable_<T<A0 , A1 , A2 , A3> BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)>
0573               : is_same<A3, callable>
0574             {};
0575         }
0576         namespace result_of
0577         {
0578
0579
0580
0581
0582
0583
0584             template<typename Expr>
0585             struct child_c<Expr, 4>
0586             {
0587
0588                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0589
0590
0591                 typedef typename Expr::proto_child4 value_type;
0592
0593
0594
0595
0596
0597                 typedef typename detail::expr_traits<typename Expr::proto_child4>::value_type type;
0598             };
0599             template<typename Expr>
0600             struct child_c<Expr &, 4>
0601             {
0602
0603                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0604
0605
0606                 typedef typename Expr::proto_child4 value_type;
0607
0608
0609
0610
0611
0612                 typedef typename detail::expr_traits<typename Expr::proto_child4>::reference type;
0613
0614
0615                 BOOST_FORCEINLINE
0616                 static type call(Expr &e)
0617                 {
0618                     return e.proto_base().child4;
0619                 }
0620             };
0621             template<typename Expr>
0622             struct child_c<Expr const &, 4>
0623             {
0624
0625                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0626
0627
0628                 typedef typename Expr::proto_child4 value_type;
0629
0630
0631
0632
0633
0634                 typedef typename detail::expr_traits<typename Expr::proto_child4>::const_reference type;
0635
0636
0637                 BOOST_FORCEINLINE
0638                 static type call(Expr const &e)
0639                 {
0640                     return e.proto_base().child4;
0641                 }
0642             };
0643         }
0644
0645
0646
0647
0648         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0649         struct function
0650         <
0651             A0 , A1 , A2 , A3 , A4
0652             , void , void , void , void , void
0653         >
0654           : proto::transform<
0655                 function<
0656                     A0 , A1 , A2 , A3 , A4
0657                     , void , void , void , void , void
0658                 >
0659               , int
0660             >
0661         {
0662             typedef proto::expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> type;
0663             typedef proto::basic_expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar;
0664             template<typename Expr, typename State, typename Data>
0665             struct impl
0666               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
0667             {};
0668
0669             typedef proto::tag::function proto_tag;
0670             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4;
0671             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;
0672         };
0673
0674
0675
0676
0677
0678
0679
0680
0681         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0682         struct nary_expr
0683         <
0684             Tag
0685             , A0 , A1 , A2 , A3 , A4
0686             , void , void , void , void , void
0687         >
0688           : proto::transform<
0689                 nary_expr<
0690                     Tag
0691                     , A0 , A1 , A2 , A3 , A4
0692                     , void , void , void , void , void
0693                 >
0694               , int
0695             >
0696         {
0697             typedef proto::expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> type;
0698             typedef proto::basic_expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar;
0699             template<typename Expr, typename State, typename Data>
0700             struct impl
0701               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
0702             {};
0703
0704             typedef Tag proto_tag;
0705             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4;
0706             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;
0707         };
0708         namespace detail
0709         {
0710             template<
0711                 template<typename , typename , typename , typename , typename> class T
0712               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
0713             >
0714             struct is_callable_<T<A0 , A1 , A2 , A3 , A4> BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)>
0715               : is_same<A4, callable>
0716             {};
0717         }
0718         namespace result_of
0719         {
0720
0721
0722
0723
0724
0725
0726             template<typename Expr>
0727             struct child_c<Expr, 5>
0728             {
0729
0730                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0731
0732
0733                 typedef typename Expr::proto_child5 value_type;
0734
0735
0736
0737
0738
0739                 typedef typename detail::expr_traits<typename Expr::proto_child5>::value_type type;
0740             };
0741             template<typename Expr>
0742             struct child_c<Expr &, 5>
0743             {
0744
0745                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0746
0747
0748                 typedef typename Expr::proto_child5 value_type;
0749
0750
0751
0752
0753
0754                 typedef typename detail::expr_traits<typename Expr::proto_child5>::reference type;
0755
0756
0757                 BOOST_FORCEINLINE
0758                 static type call(Expr &e)
0759                 {
0760                     return e.proto_base().child5;
0761                 }
0762             };
0763             template<typename Expr>
0764             struct child_c<Expr const &, 5>
0765             {
0766
0767                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0768
0769
0770                 typedef typename Expr::proto_child5 value_type;
0771
0772
0773
0774
0775
0776                 typedef typename detail::expr_traits<typename Expr::proto_child5>::const_reference type;
0777
0778
0779                 BOOST_FORCEINLINE
0780                 static type call(Expr const &e)
0781                 {
0782                     return e.proto_base().child5;
0783                 }
0784             };
0785         }
0786
0787
0788
0789
0790         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0791         struct function
0792         <
0793             A0 , A1 , A2 , A3 , A4 , A5
0794             , void , void , void , void
0795         >
0796           : proto::transform<
0797                 function<
0798                     A0 , A1 , A2 , A3 , A4 , A5
0799                     , void , void , void , void
0800                 >
0801               , int
0802             >
0803         {
0804             typedef proto::expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type;
0805             typedef proto::basic_expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar;
0806             template<typename Expr, typename State, typename Data>
0807             struct impl
0808               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
0809             {};
0810
0811             typedef proto::tag::function proto_tag;
0812             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5;
0813             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;
0814         };
0815
0816
0817
0818
0819
0820
0821
0822
0823         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0824         struct nary_expr
0825         <
0826             Tag
0827             , A0 , A1 , A2 , A3 , A4 , A5
0828             , void , void , void , void
0829         >
0830           : proto::transform<
0831                 nary_expr<
0832                     Tag
0833                     , A0 , A1 , A2 , A3 , A4 , A5
0834                     , void , void , void , void
0835                 >
0836               , int
0837             >
0838         {
0839             typedef proto::expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type;
0840             typedef proto::basic_expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar;
0841             template<typename Expr, typename State, typename Data>
0842             struct impl
0843               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
0844             {};
0845
0846             typedef Tag proto_tag;
0847             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5;
0848             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;
0849         };
0850         namespace detail
0851         {
0852             template<
0853                 template<typename , typename , typename , typename , typename , typename> class T
0854               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
0855             >
0856             struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5> BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)>
0857               : is_same<A5, callable>
0858             {};
0859         }
0860         namespace result_of
0861         {
0862
0863
0864
0865
0866
0867
0868             template<typename Expr>
0869             struct child_c<Expr, 6>
0870             {
0871
0872                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0873
0874
0875                 typedef typename Expr::proto_child6 value_type;
0876
0877
0878
0879
0880
0881                 typedef typename detail::expr_traits<typename Expr::proto_child6>::value_type type;
0882             };
0883             template<typename Expr>
0884             struct child_c<Expr &, 6>
0885             {
0886
0887                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0888
0889
0890                 typedef typename Expr::proto_child6 value_type;
0891
0892
0893
0894
0895
0896                 typedef typename detail::expr_traits<typename Expr::proto_child6>::reference type;
0897
0898
0899                 BOOST_FORCEINLINE
0900                 static type call(Expr &e)
0901                 {
0902                     return e.proto_base().child6;
0903                 }
0904             };
0905             template<typename Expr>
0906             struct child_c<Expr const &, 6>
0907             {
0908
0909                 BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
0910
0911
0912                 typedef typename Expr::proto_child6 value_type;
0913
0914
0915
0916
0917
0918                 typedef typename detail::expr_traits<typename Expr::proto_child6>::const_reference type;
0919
0920
0921                 BOOST_FORCEINLINE
0922                 static type call(Expr const &e)
0923                 {
0924                     return e.proto_base().child6;
0925                 }
0926             };
0927         }
0928
0929
0930
0931
0932         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0933         struct function
0934         <
0935             A0 , A1 , A2 , A3 , A4 , A5 , A6
0936             , void , void , void
0937         >
0938           : proto::transform<
0939                 function<
0940                     A0 , A1 , A2 , A3 , A4 , A5 , A6
0941                     , void , void , void
0942                 >
0943               , int
0944             >
0945         {
0946             typedef proto::expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type;
0947             typedef proto::basic_expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar;
0948             template<typename Expr, typename State, typename Data>
0949             struct impl
0950               : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
0951             {};
0952
0953             typedef proto::tag::function proto_tag;
0954             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;
0955             typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9;
0956         };
0957
0958
0959
0960
0961
0962
0963
0964
0965         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0966         struct nary_expr
0967         <
0968             Tag
0969             , A0 , A1 , A2 , A3 , A4 , A5 , A6
0970             , void , void , void
0971         >
0972           : proto::transform<
0973                 nary_expr<
0974                     Tag
0975                     , A0 , A1 , A2 , A3 , A4 , A5 , A6
0976                     , void , void , void
0977                 >
0978               , int
0979             >
0980         {
0981             typedef proto::expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type;
0982             typedef proto::basic_expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar;
0983             template<typename Expr, typename State, typename Data>
0984             struct impl
0985               : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
0986             {};
0987
0988             typedef Tag proto_tag;
0989             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;
0990             typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9;
0991         };
0992         namespace detail
0993         {
0994             template<
0995                 template<typename , typename , typename , typename , typename , typename , typename> class T
0996               , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
0997             >
0998             struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6> BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)>
0999               : 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         }