cpp03/preprocessed/call_10.hpp

0001 /*==============================================================================
0002     Copyright (c) 2005-2010 Joel de Guzman
0003     Copyright (c) 2010 Thomas Heller
0004
0005     Distributed under the Boost Software License, Version 1.0. (See accompanying
0006     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0007 ==============================================================================*/
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017         template <typename Fun, typename Expr, typename State, typename Data>
0018         struct call_impl<Fun, Expr, State, Data, 1>
0019             : proto::transform_impl<Expr, State, Data>
0020         {
0021             typedef
0022                 typename boost::phoenix::result_of::context<State, Data>::type
0023                 context_type;
0024             typedef typename proto::result_of::child_c<Expr, 0>::type A0;
0025             typedef
0026                 typename boost::result_of<
0027                     Fun(A0, context_type)
0028                 >::type
0029                 result_type;
0030             result_type operator()(
0031                 typename call_impl::expr_param e
0032               , typename call_impl::state_param s
0033               , typename call_impl::data_param d
0034             ) const
0035             {
0036                 return
0037                     Fun()(
0038                         proto::child_c< 0>(e)
0039                       , boost::phoenix::context(s, d)
0040                     );
0041             }
0042         };
0043
0044
0045
0046
0047
0048
0049
0050
0051         template <typename Fun, typename Expr, typename State, typename Data>
0052         struct call_impl<Fun, Expr, State, Data, 2>
0053             : proto::transform_impl<Expr, State, Data>
0054         {
0055             typedef
0056                 typename boost::phoenix::result_of::context<State, Data>::type
0057                 context_type;
0058             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1;
0059             typedef
0060                 typename boost::result_of<
0061                     Fun(A0 , A1, context_type)
0062                 >::type
0063                 result_type;
0064             result_type operator()(
0065                 typename call_impl::expr_param e
0066               , typename call_impl::state_param s
0067               , typename call_impl::data_param d
0068             ) const
0069             {
0070                 return
0071                     Fun()(
0072                         proto::child_c< 0>(e) , proto::child_c< 1>(e)
0073                       , boost::phoenix::context(s, d)
0074                     );
0075             }
0076         };
0077
0078
0079
0080
0081
0082
0083
0084
0085         template <typename Fun, typename Expr, typename State, typename Data>
0086         struct call_impl<Fun, Expr, State, Data, 3>
0087             : proto::transform_impl<Expr, State, Data>
0088         {
0089             typedef
0090                 typename boost::phoenix::result_of::context<State, Data>::type
0091                 context_type;
0092             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2;
0093             typedef
0094                 typename boost::result_of<
0095                     Fun(A0 , A1 , A2, context_type)
0096                 >::type
0097                 result_type;
0098             result_type operator()(
0099                 typename call_impl::expr_param e
0100               , typename call_impl::state_param s
0101               , typename call_impl::data_param d
0102             ) const
0103             {
0104                 return
0105                     Fun()(
0106                         proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e)
0107                       , boost::phoenix::context(s, d)
0108                     );
0109             }
0110         };
0111
0112
0113
0114
0115
0116
0117
0118
0119         template <typename Fun, typename Expr, typename State, typename Data>
0120         struct call_impl<Fun, Expr, State, Data, 4>
0121             : proto::transform_impl<Expr, State, Data>
0122         {
0123             typedef
0124                 typename boost::phoenix::result_of::context<State, Data>::type
0125                 context_type;
0126             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3;
0127             typedef
0128                 typename boost::result_of<
0129                     Fun(A0 , A1 , A2 , A3, context_type)
0130                 >::type
0131                 result_type;
0132             result_type operator()(
0133                 typename call_impl::expr_param e
0134               , typename call_impl::state_param s
0135               , typename call_impl::data_param d
0136             ) const
0137             {
0138                 return
0139                     Fun()(
0140                         proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e)
0141                       , boost::phoenix::context(s, d)
0142                     );
0143             }
0144         };
0145
0146
0147
0148
0149
0150
0151
0152
0153         template <typename Fun, typename Expr, typename State, typename Data>
0154         struct call_impl<Fun, Expr, State, Data, 5>
0155             : proto::transform_impl<Expr, State, Data>
0156         {
0157             typedef
0158                 typename boost::phoenix::result_of::context<State, Data>::type
0159                 context_type;
0160             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4;
0161             typedef
0162                 typename boost::result_of<
0163                     Fun(A0 , A1 , A2 , A3 , A4, context_type)
0164                 >::type
0165                 result_type;
0166             result_type operator()(
0167                 typename call_impl::expr_param e
0168               , typename call_impl::state_param s
0169               , typename call_impl::data_param d
0170             ) const
0171             {
0172                 return
0173                     Fun()(
0174                         proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e)
0175                       , boost::phoenix::context(s, d)
0176                     );
0177             }
0178         };
0179
0180
0181
0182
0183
0184
0185
0186
0187         template <typename Fun, typename Expr, typename State, typename Data>
0188         struct call_impl<Fun, Expr, State, Data, 6>
0189             : proto::transform_impl<Expr, State, Data>
0190         {
0191             typedef
0192                 typename boost::phoenix::result_of::context<State, Data>::type
0193                 context_type;
0194             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5;
0195             typedef
0196                 typename boost::result_of<
0197                     Fun(A0 , A1 , A2 , A3 , A4 , A5, context_type)
0198                 >::type
0199                 result_type;
0200             result_type operator()(
0201                 typename call_impl::expr_param e
0202               , typename call_impl::state_param s
0203               , typename call_impl::data_param d
0204             ) const
0205             {
0206                 return
0207                     Fun()(
0208                         proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e)
0209                       , boost::phoenix::context(s, d)
0210                     );
0211             }
0212         };
0213
0214
0215
0216
0217
0218
0219
0220
0221         template <typename Fun, typename Expr, typename State, typename Data>
0222         struct call_impl<Fun, Expr, State, Data, 7>
0223             : proto::transform_impl<Expr, State, Data>
0224         {
0225             typedef
0226                 typename boost::phoenix::result_of::context<State, Data>::type
0227                 context_type;
0228             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6;
0229             typedef
0230                 typename boost::result_of<
0231                     Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6, context_type)
0232                 >::type
0233                 result_type;
0234             result_type operator()(
0235                 typename call_impl::expr_param e
0236               , typename call_impl::state_param s
0237               , typename call_impl::data_param d
0238             ) const
0239             {
0240                 return
0241                     Fun()(
0242                         proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e)
0243                       , boost::phoenix::context(s, d)
0244                     );
0245             }
0246         };
0247
0248
0249
0250
0251
0252
0253
0254
0255         template <typename Fun, typename Expr, typename State, typename Data>
0256         struct call_impl<Fun, Expr, State, Data, 8>
0257             : proto::transform_impl<Expr, State, Data>
0258         {
0259             typedef
0260                 typename boost::phoenix::result_of::context<State, Data>::type
0261                 context_type;
0262             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7;
0263             typedef
0264                 typename boost::result_of<
0265                     Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7, context_type)
0266                 >::type
0267                 result_type;
0268             result_type operator()(
0269                 typename call_impl::expr_param e
0270               , typename call_impl::state_param s
0271               , typename call_impl::data_param d
0272             ) const
0273             {
0274                 return
0275                     Fun()(
0276                         proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e)
0277                       , boost::phoenix::context(s, d)
0278                     );
0279             }
0280         };
0281
0282
0283
0284
0285
0286
0287
0288
0289         template <typename Fun, typename Expr, typename State, typename Data>
0290         struct call_impl<Fun, Expr, State, Data, 9>
0291             : proto::transform_impl<Expr, State, Data>
0292         {
0293             typedef
0294                 typename boost::phoenix::result_of::context<State, Data>::type
0295                 context_type;
0296             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8;
0297             typedef
0298                 typename boost::result_of<
0299                     Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8, context_type)
0300                 >::type
0301                 result_type;
0302             result_type operator()(
0303                 typename call_impl::expr_param e
0304               , typename call_impl::state_param s
0305               , typename call_impl::data_param d
0306             ) const
0307             {
0308                 return
0309                     Fun()(
0310                         proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e)
0311                       , boost::phoenix::context(s, d)
0312                     );
0313             }
0314         };
0315
0316
0317
0318
0319
0320
0321
0322
0323         template <typename Fun, typename Expr, typename State, typename Data>
0324         struct call_impl<Fun, Expr, State, Data, 10>
0325             : proto::transform_impl<Expr, State, Data>
0326         {
0327             typedef
0328                 typename boost::phoenix::result_of::context<State, Data>::type
0329                 context_type;
0330             typedef typename proto::result_of::child_c<Expr, 0>::type A0; typedef typename proto::result_of::child_c<Expr, 1>::type A1; typedef typename proto::result_of::child_c<Expr, 2>::type A2; typedef typename proto::result_of::child_c<Expr, 3>::type A3; typedef typename proto::result_of::child_c<Expr, 4>::type A4; typedef typename proto::result_of::child_c<Expr, 5>::type A5; typedef typename proto::result_of::child_c<Expr, 6>::type A6; typedef typename proto::result_of::child_c<Expr, 7>::type A7; typedef typename proto::result_of::child_c<Expr, 8>::type A8; typedef typename proto::result_of::child_c<Expr, 9>::type A9;
0331             typedef
0332                 typename boost::result_of<
0333                     Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9, context_type)
0334                 >::type
0335                 result_type;
0336             result_type operator()(
0337                 typename call_impl::expr_param e
0338               , typename call_impl::state_param s
0339               , typename call_impl::data_param d
0340             ) const
0341             {
0342                 return
0343                     Fun()(
0344                         proto::child_c< 0>(e) , proto::child_c< 1>(e) , proto::child_c< 2>(e) , proto::child_c< 3>(e) , proto::child_c< 4>(e) , proto::child_c< 5>(e) , proto::child_c< 6>(e) , proto::child_c< 7>(e) , proto::child_c< 8>(e) , proto::child_c< 9>(e)
0345                       , boost::phoenix::context(s, d)
0346                     );
0347             }
0348         };