cpp03/preprocessed/member_function_ptr_20.hpp

0001 /*=============================================================================
0002     Copyright (c) 2001-2007 Joel de Guzman
0003
0004     Distributed under the Boost Software License, Version 1.0. (See accompanying
0005     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0006 ==============================================================================*/
0007
0008
0009
0010
0011
0012
0013
0014     template <>
0015     struct member_function_ptr_impl<1>
0016     {
0017         template <typename RT, typename FP>
0018         struct impl
0019         {
0020             typedef RT result_type;
0021             impl(FP fp_)
0022                 : fp(fp_) {}
0023             template <typename Class, typename A0>
0024             RT operator()(Class& obj, A0 & a0) const
0025             {
0026                 BOOST_PROTO_USE_GET_POINTER();
0027                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0028                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0);
0029             }
0030             template <typename Class, typename A0>
0031             RT operator()(Class* obj, A0 & a0) const
0032             {
0033                 return (obj->*fp)(a0);
0034             }
0035             FP fp;
0036         };
0037     };
0038
0039
0040
0041
0042
0043
0044
0045     template <>
0046     struct member_function_ptr_impl<2>
0047     {
0048         template <typename RT, typename FP>
0049         struct impl
0050         {
0051             typedef RT result_type;
0052             impl(FP fp_)
0053                 : fp(fp_) {}
0054             template <typename Class, typename A0 , typename A1>
0055             RT operator()(Class& obj, A0 & a0 , A1 & a1) const
0056             {
0057                 BOOST_PROTO_USE_GET_POINTER();
0058                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0059                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1);
0060             }
0061             template <typename Class, typename A0 , typename A1>
0062             RT operator()(Class* obj, A0 & a0 , A1 & a1) const
0063             {
0064                 return (obj->*fp)(a0 , a1);
0065             }
0066             FP fp;
0067         };
0068     };
0069
0070
0071
0072
0073
0074
0075
0076     template <>
0077     struct member_function_ptr_impl<3>
0078     {
0079         template <typename RT, typename FP>
0080         struct impl
0081         {
0082             typedef RT result_type;
0083             impl(FP fp_)
0084                 : fp(fp_) {}
0085             template <typename Class, typename A0 , typename A1 , typename A2>
0086             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2) const
0087             {
0088                 BOOST_PROTO_USE_GET_POINTER();
0089                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0090                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2);
0091             }
0092             template <typename Class, typename A0 , typename A1 , typename A2>
0093             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2) const
0094             {
0095                 return (obj->*fp)(a0 , a1 , a2);
0096             }
0097             FP fp;
0098         };
0099     };
0100
0101
0102
0103
0104
0105
0106
0107     template <>
0108     struct member_function_ptr_impl<4>
0109     {
0110         template <typename RT, typename FP>
0111         struct impl
0112         {
0113             typedef RT result_type;
0114             impl(FP fp_)
0115                 : fp(fp_) {}
0116             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3>
0117             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const
0118             {
0119                 BOOST_PROTO_USE_GET_POINTER();
0120                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0121                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3);
0122             }
0123             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3>
0124             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const
0125             {
0126                 return (obj->*fp)(a0 , a1 , a2 , a3);
0127             }
0128             FP fp;
0129         };
0130     };
0131
0132
0133
0134
0135
0136
0137
0138     template <>
0139     struct member_function_ptr_impl<5>
0140     {
0141         template <typename RT, typename FP>
0142         struct impl
0143         {
0144             typedef RT result_type;
0145             impl(FP fp_)
0146                 : fp(fp_) {}
0147             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0148             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const
0149             {
0150                 BOOST_PROTO_USE_GET_POINTER();
0151                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0152                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4);
0153             }
0154             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0155             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const
0156             {
0157                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4);
0158             }
0159             FP fp;
0160         };
0161     };
0162
0163
0164
0165
0166
0167
0168
0169     template <>
0170     struct member_function_ptr_impl<6>
0171     {
0172         template <typename RT, typename FP>
0173         struct impl
0174         {
0175             typedef RT result_type;
0176             impl(FP fp_)
0177                 : fp(fp_) {}
0178             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0179             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const
0180             {
0181                 BOOST_PROTO_USE_GET_POINTER();
0182                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0183                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5);
0184             }
0185             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0186             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const
0187             {
0188                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5);
0189             }
0190             FP fp;
0191         };
0192     };
0193
0194
0195
0196
0197
0198
0199
0200     template <>
0201     struct member_function_ptr_impl<7>
0202     {
0203         template <typename RT, typename FP>
0204         struct impl
0205         {
0206             typedef RT result_type;
0207             impl(FP fp_)
0208                 : fp(fp_) {}
0209             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0210             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const
0211             {
0212                 BOOST_PROTO_USE_GET_POINTER();
0213                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0214                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6);
0215             }
0216             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0217             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const
0218             {
0219                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6);
0220             }
0221             FP fp;
0222         };
0223     };
0224
0225
0226
0227
0228
0229
0230
0231     template <>
0232     struct member_function_ptr_impl<8>
0233     {
0234         template <typename RT, typename FP>
0235         struct impl
0236         {
0237             typedef RT result_type;
0238             impl(FP fp_)
0239                 : fp(fp_) {}
0240             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0241             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const
0242             {
0243                 BOOST_PROTO_USE_GET_POINTER();
0244                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0245                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
0246             }
0247             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0248             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const
0249             {
0250                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
0251             }
0252             FP fp;
0253         };
0254     };
0255
0256
0257
0258
0259
0260
0261
0262     template <>
0263     struct member_function_ptr_impl<9>
0264     {
0265         template <typename RT, typename FP>
0266         struct impl
0267         {
0268             typedef RT result_type;
0269             impl(FP fp_)
0270                 : fp(fp_) {}
0271             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0272             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const
0273             {
0274                 BOOST_PROTO_USE_GET_POINTER();
0275                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0276                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
0277             }
0278             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0279             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const
0280             {
0281                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
0282             }
0283             FP fp;
0284         };
0285     };
0286
0287
0288
0289
0290
0291
0292
0293     template <>
0294     struct member_function_ptr_impl<10>
0295     {
0296         template <typename RT, typename FP>
0297         struct impl
0298         {
0299             typedef RT result_type;
0300             impl(FP fp_)
0301                 : fp(fp_) {}
0302             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
0303             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const
0304             {
0305                 BOOST_PROTO_USE_GET_POINTER();
0306                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0307                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
0308             }
0309             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
0310             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const
0311             {
0312                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
0313             }
0314             FP fp;
0315         };
0316     };
0317
0318
0319
0320
0321
0322
0323
0324     template <>
0325     struct member_function_ptr_impl<11>
0326     {
0327         template <typename RT, typename FP>
0328         struct impl
0329         {
0330             typedef RT result_type;
0331             impl(FP fp_)
0332                 : fp(fp_) {}
0333             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
0334             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const
0335             {
0336                 BOOST_PROTO_USE_GET_POINTER();
0337                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0338                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);
0339             }
0340             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
0341             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const
0342             {
0343                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);
0344             }
0345             FP fp;
0346         };
0347     };
0348
0349
0350
0351
0352
0353
0354
0355     template <>
0356     struct member_function_ptr_impl<12>
0357     {
0358         template <typename RT, typename FP>
0359         struct impl
0360         {
0361             typedef RT result_type;
0362             impl(FP fp_)
0363                 : fp(fp_) {}
0364             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
0365             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11) const
0366             {
0367                 BOOST_PROTO_USE_GET_POINTER();
0368                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0369                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);
0370             }
0371             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
0372             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11) const
0373             {
0374                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);
0375             }
0376             FP fp;
0377         };
0378     };
0379
0380
0381
0382
0383
0384
0385
0386     template <>
0387     struct member_function_ptr_impl<13>
0388     {
0389         template <typename RT, typename FP>
0390         struct impl
0391         {
0392             typedef RT result_type;
0393             impl(FP fp_)
0394                 : fp(fp_) {}
0395             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>
0396             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12) const
0397             {
0398                 BOOST_PROTO_USE_GET_POINTER();
0399                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0400                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);
0401             }
0402             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>
0403             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12) const
0404             {
0405                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);
0406             }
0407             FP fp;
0408         };
0409     };
0410
0411
0412
0413
0414
0415
0416
0417     template <>
0418     struct member_function_ptr_impl<14>
0419     {
0420         template <typename RT, typename FP>
0421         struct impl
0422         {
0423             typedef RT result_type;
0424             impl(FP fp_)
0425                 : fp(fp_) {}
0426             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>
0427             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13) const
0428             {
0429                 BOOST_PROTO_USE_GET_POINTER();
0430                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0431                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);
0432             }
0433             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>
0434             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13) const
0435             {
0436                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);
0437             }
0438             FP fp;
0439         };
0440     };
0441
0442
0443
0444
0445
0446
0447
0448     template <>
0449     struct member_function_ptr_impl<15>
0450     {
0451         template <typename RT, typename FP>
0452         struct impl
0453         {
0454             typedef RT result_type;
0455             impl(FP fp_)
0456                 : fp(fp_) {}
0457             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>
0458             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14) const
0459             {
0460                 BOOST_PROTO_USE_GET_POINTER();
0461                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0462                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);
0463             }
0464             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>
0465             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14) const
0466             {
0467                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);
0468             }
0469             FP fp;
0470         };
0471     };
0472
0473
0474
0475
0476
0477
0478
0479     template <>
0480     struct member_function_ptr_impl<16>
0481     {
0482         template <typename RT, typename FP>
0483         struct impl
0484         {
0485             typedef RT result_type;
0486             impl(FP fp_)
0487                 : fp(fp_) {}
0488             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>
0489             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15) const
0490             {
0491                 BOOST_PROTO_USE_GET_POINTER();
0492                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0493                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);
0494             }
0495             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>
0496             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15) const
0497             {
0498                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);
0499             }
0500             FP fp;
0501         };
0502     };
0503
0504
0505
0506
0507
0508
0509
0510     template <>
0511     struct member_function_ptr_impl<17>
0512     {
0513         template <typename RT, typename FP>
0514         struct impl
0515         {
0516             typedef RT result_type;
0517             impl(FP fp_)
0518                 : fp(fp_) {}
0519             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>
0520             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16) const
0521             {
0522                 BOOST_PROTO_USE_GET_POINTER();
0523                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0524                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);
0525             }
0526             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>
0527             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16) const
0528             {
0529                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);
0530             }
0531             FP fp;
0532         };
0533     };
0534
0535
0536
0537
0538
0539
0540
0541     template <>
0542     struct member_function_ptr_impl<18>
0543     {
0544         template <typename RT, typename FP>
0545         struct impl
0546         {
0547             typedef RT result_type;
0548             impl(FP fp_)
0549                 : fp(fp_) {}
0550             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>
0551             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17) const
0552             {
0553                 BOOST_PROTO_USE_GET_POINTER();
0554                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0555                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);
0556             }
0557             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>
0558             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17) const
0559             {
0560                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);
0561             }
0562             FP fp;
0563         };
0564     };
0565
0566
0567
0568
0569
0570
0571
0572     template <>
0573     struct member_function_ptr_impl<19>
0574     {
0575         template <typename RT, typename FP>
0576         struct impl
0577         {
0578             typedef RT result_type;
0579             impl(FP fp_)
0580                 : fp(fp_) {}
0581             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>
0582             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18) const
0583             {
0584                 BOOST_PROTO_USE_GET_POINTER();
0585                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0586                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);
0587             }
0588             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>
0589             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18) const
0590             {
0591                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);
0592             }
0593             FP fp;
0594         };
0595     };
0596
0597
0598
0599
0600
0601
0602
0603     template <>
0604     struct member_function_ptr_impl<20>
0605     {
0606         template <typename RT, typename FP>
0607         struct impl
0608         {
0609             typedef RT result_type;
0610             impl(FP fp_)
0611                 : fp(fp_) {}
0612             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>
0613             RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19) const
0614             {
0615                 BOOST_PROTO_USE_GET_POINTER();
0616                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0617                 return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);
0618             }
0619             template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>
0620             RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19) const
0621             {
0622                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);
0623             }
0624             FP fp;
0625         };
0626     };