Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-02-23 09:48:24 

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     };
0627     
0628     
0629     
0630     
0631     
0632     
0633     
0634     template <>
0635     struct member_function_ptr_impl<21>
0636     {
0637         template <typename RT, typename FP>
0638         struct impl
0639         {
0640             typedef RT result_type;
0641             impl(FP fp_)
0642                 : fp(fp_) {}
0643             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 , typename A20>
0644             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 , A20 & a20) const
0645             {
0646                 BOOST_PROTO_USE_GET_POINTER();
0647                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0648                 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 , a20);
0649             }
0650             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 , typename A20>
0651             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 , A20 & a20) const
0652             {
0653                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20);
0654             }
0655             FP fp;
0656         };
0657     };
0658     
0659     
0660     
0661     
0662     
0663     
0664     
0665     template <>
0666     struct member_function_ptr_impl<22>
0667     {
0668         template <typename RT, typename FP>
0669         struct impl
0670         {
0671             typedef RT result_type;
0672             impl(FP fp_)
0673                 : fp(fp_) {}
0674             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 , typename A20 , typename A21>
0675             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 , A20 & a20 , A21 & a21) const
0676             {
0677                 BOOST_PROTO_USE_GET_POINTER();
0678                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0679                 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 , a20 , a21);
0680             }
0681             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 , typename A20 , typename A21>
0682             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 , A20 & a20 , A21 & a21) const
0683             {
0684                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21);
0685             }
0686             FP fp;
0687         };
0688     };
0689     
0690     
0691     
0692     
0693     
0694     
0695     
0696     template <>
0697     struct member_function_ptr_impl<23>
0698     {
0699         template <typename RT, typename FP>
0700         struct impl
0701         {
0702             typedef RT result_type;
0703             impl(FP fp_)
0704                 : fp(fp_) {}
0705             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 , typename A20 , typename A21 , typename A22>
0706             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 , A20 & a20 , A21 & a21 , A22 & a22) const
0707             {
0708                 BOOST_PROTO_USE_GET_POINTER();
0709                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0710                 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 , a20 , a21 , a22);
0711             }
0712             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 , typename A20 , typename A21 , typename A22>
0713             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 , A20 & a20 , A21 & a21 , A22 & a22) const
0714             {
0715                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22);
0716             }
0717             FP fp;
0718         };
0719     };
0720     
0721     
0722     
0723     
0724     
0725     
0726     
0727     template <>
0728     struct member_function_ptr_impl<24>
0729     {
0730         template <typename RT, typename FP>
0731         struct impl
0732         {
0733             typedef RT result_type;
0734             impl(FP fp_)
0735                 : fp(fp_) {}
0736             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 , typename A20 , typename A21 , typename A22 , typename A23>
0737             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23) const
0738             {
0739                 BOOST_PROTO_USE_GET_POINTER();
0740                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0741                 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 , a20 , a21 , a22 , a23);
0742             }
0743             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 , typename A20 , typename A21 , typename A22 , typename A23>
0744             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23) const
0745             {
0746                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23);
0747             }
0748             FP fp;
0749         };
0750     };
0751     
0752     
0753     
0754     
0755     
0756     
0757     
0758     template <>
0759     struct member_function_ptr_impl<25>
0760     {
0761         template <typename RT, typename FP>
0762         struct impl
0763         {
0764             typedef RT result_type;
0765             impl(FP fp_)
0766                 : fp(fp_) {}
0767             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24>
0768             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24) const
0769             {
0770                 BOOST_PROTO_USE_GET_POINTER();
0771                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0772                 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 , a20 , a21 , a22 , a23 , a24);
0773             }
0774             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24>
0775             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24) const
0776             {
0777                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24);
0778             }
0779             FP fp;
0780         };
0781     };
0782     
0783     
0784     
0785     
0786     
0787     
0788     
0789     template <>
0790     struct member_function_ptr_impl<26>
0791     {
0792         template <typename RT, typename FP>
0793         struct impl
0794         {
0795             typedef RT result_type;
0796             impl(FP fp_)
0797                 : fp(fp_) {}
0798             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25>
0799             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25) const
0800             {
0801                 BOOST_PROTO_USE_GET_POINTER();
0802                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0803                 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 , a20 , a21 , a22 , a23 , a24 , a25);
0804             }
0805             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25>
0806             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25) const
0807             {
0808                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25);
0809             }
0810             FP fp;
0811         };
0812     };
0813     
0814     
0815     
0816     
0817     
0818     
0819     
0820     template <>
0821     struct member_function_ptr_impl<27>
0822     {
0823         template <typename RT, typename FP>
0824         struct impl
0825         {
0826             typedef RT result_type;
0827             impl(FP fp_)
0828                 : fp(fp_) {}
0829             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26>
0830             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26) const
0831             {
0832                 BOOST_PROTO_USE_GET_POINTER();
0833                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0834                 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 , a20 , a21 , a22 , a23 , a24 , a25 , a26);
0835             }
0836             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26>
0837             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26) const
0838             {
0839                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26);
0840             }
0841             FP fp;
0842         };
0843     };
0844     
0845     
0846     
0847     
0848     
0849     
0850     
0851     template <>
0852     struct member_function_ptr_impl<28>
0853     {
0854         template <typename RT, typename FP>
0855         struct impl
0856         {
0857             typedef RT result_type;
0858             impl(FP fp_)
0859                 : fp(fp_) {}
0860             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27>
0861             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27) const
0862             {
0863                 BOOST_PROTO_USE_GET_POINTER();
0864                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0865                 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 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27);
0866             }
0867             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27>
0868             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27) const
0869             {
0870                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27);
0871             }
0872             FP fp;
0873         };
0874     };
0875     
0876     
0877     
0878     
0879     
0880     
0881     
0882     template <>
0883     struct member_function_ptr_impl<29>
0884     {
0885         template <typename RT, typename FP>
0886         struct impl
0887         {
0888             typedef RT result_type;
0889             impl(FP fp_)
0890                 : fp(fp_) {}
0891             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28>
0892             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28) const
0893             {
0894                 BOOST_PROTO_USE_GET_POINTER();
0895                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0896                 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 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28);
0897             }
0898             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28>
0899             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28) const
0900             {
0901                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28);
0902             }
0903             FP fp;
0904         };
0905     };
0906     
0907     
0908     
0909     
0910     
0911     
0912     
0913     template <>
0914     struct member_function_ptr_impl<30>
0915     {
0916         template <typename RT, typename FP>
0917         struct impl
0918         {
0919             typedef RT result_type;
0920             impl(FP fp_)
0921                 : fp(fp_) {}
0922             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29>
0923             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29) const
0924             {
0925                 BOOST_PROTO_USE_GET_POINTER();
0926                 typedef typename proto::detail::class_member_traits<FP>::class_type class_type;
0927                 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 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29);
0928             }
0929             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29>
0930             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29) const
0931             {
0932                 return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29);
0933             }
0934             FP fp;
0935         };
0936     };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!