cpp03/preprocessed/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 <typename Dummy>
0015     struct function_ptr_impl<2, Dummy>
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 A0 , typename A1>
0024             RT operator()(A0 & a0 , A1 & a1) const
0025             {
0026                 return fp(a0 , a1);
0027             }
0028             FP fp;
0029         };
0030     };
0031
0032
0033
0034
0035
0036
0037
0038     template <typename Dummy>
0039     struct function_ptr_impl<3, Dummy>
0040     {
0041         template <typename RT, typename FP>
0042         struct impl
0043         {
0044             typedef RT result_type;
0045             impl(FP fp_)
0046                 : fp(fp_) {}
0047             template <typename A0 , typename A1 , typename A2>
0048             RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const
0049             {
0050                 return fp(a0 , a1 , a2);
0051             }
0052             FP fp;
0053         };
0054     };
0055
0056
0057
0058
0059
0060
0061
0062     template <typename Dummy>
0063     struct function_ptr_impl<4, Dummy>
0064     {
0065         template <typename RT, typename FP>
0066         struct impl
0067         {
0068             typedef RT result_type;
0069             impl(FP fp_)
0070                 : fp(fp_) {}
0071             template <typename A0 , typename A1 , typename A2 , typename A3>
0072             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const
0073             {
0074                 return fp(a0 , a1 , a2 , a3);
0075             }
0076             FP fp;
0077         };
0078     };
0079
0080
0081
0082
0083
0084
0085
0086     template <typename Dummy>
0087     struct function_ptr_impl<5, Dummy>
0088     {
0089         template <typename RT, typename FP>
0090         struct impl
0091         {
0092             typedef RT result_type;
0093             impl(FP fp_)
0094                 : fp(fp_) {}
0095             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0096             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const
0097             {
0098                 return fp(a0 , a1 , a2 , a3 , a4);
0099             }
0100             FP fp;
0101         };
0102     };
0103
0104
0105
0106
0107
0108
0109
0110     template <typename Dummy>
0111     struct function_ptr_impl<6, Dummy>
0112     {
0113         template <typename RT, typename FP>
0114         struct impl
0115         {
0116             typedef RT result_type;
0117             impl(FP fp_)
0118                 : fp(fp_) {}
0119             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0120             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const
0121             {
0122                 return fp(a0 , a1 , a2 , a3 , a4 , a5);
0123             }
0124             FP fp;
0125         };
0126     };
0127
0128
0129
0130
0131
0132
0133
0134     template <typename Dummy>
0135     struct function_ptr_impl<7, Dummy>
0136     {
0137         template <typename RT, typename FP>
0138         struct impl
0139         {
0140             typedef RT result_type;
0141             impl(FP fp_)
0142                 : fp(fp_) {}
0143             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0144             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const
0145             {
0146                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);
0147             }
0148             FP fp;
0149         };
0150     };
0151
0152
0153
0154
0155
0156
0157
0158     template <typename Dummy>
0159     struct function_ptr_impl<8, Dummy>
0160     {
0161         template <typename RT, typename FP>
0162         struct impl
0163         {
0164             typedef RT result_type;
0165             impl(FP fp_)
0166                 : fp(fp_) {}
0167             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0168             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const
0169             {
0170                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
0171             }
0172             FP fp;
0173         };
0174     };
0175
0176
0177
0178
0179
0180
0181
0182     template <typename Dummy>
0183     struct function_ptr_impl<9, Dummy>
0184     {
0185         template <typename RT, typename FP>
0186         struct impl
0187         {
0188             typedef RT result_type;
0189             impl(FP fp_)
0190                 : fp(fp_) {}
0191             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0192             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const
0193             {
0194                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
0195             }
0196             FP fp;
0197         };
0198     };
0199
0200
0201
0202
0203
0204
0205
0206     template <typename Dummy>
0207     struct function_ptr_impl<10, Dummy>
0208     {
0209         template <typename RT, typename FP>
0210         struct impl
0211         {
0212             typedef RT result_type;
0213             impl(FP fp_)
0214                 : fp(fp_) {}
0215             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
0216             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const
0217             {
0218                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
0219             }
0220             FP fp;
0221         };
0222     };
0223
0224
0225
0226
0227
0228
0229
0230     template <typename Dummy>
0231     struct function_ptr_impl<11, Dummy>
0232     {
0233         template <typename RT, typename FP>
0234         struct impl
0235         {
0236             typedef RT result_type;
0237             impl(FP fp_)
0238                 : fp(fp_) {}
0239             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
0240             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const
0241             {
0242                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);
0243             }
0244             FP fp;
0245         };
0246     };
0247
0248
0249
0250
0251
0252
0253
0254     template <typename Dummy>
0255     struct function_ptr_impl<12, Dummy>
0256     {
0257         template <typename RT, typename FP>
0258         struct impl
0259         {
0260             typedef RT result_type;
0261             impl(FP fp_)
0262                 : fp(fp_) {}
0263             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
0264             RT operator()(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
0265             {
0266                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);
0267             }
0268             FP fp;
0269         };
0270     };
0271
0272
0273
0274
0275
0276
0277
0278     template <typename Dummy>
0279     struct function_ptr_impl<13, Dummy>
0280     {
0281         template <typename RT, typename FP>
0282         struct impl
0283         {
0284             typedef RT result_type;
0285             impl(FP fp_)
0286                 : fp(fp_) {}
0287             template <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>
0288             RT operator()(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
0289             {
0290                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);
0291             }
0292             FP fp;
0293         };
0294     };
0295
0296
0297
0298
0299
0300
0301
0302     template <typename Dummy>
0303     struct function_ptr_impl<14, Dummy>
0304     {
0305         template <typename RT, typename FP>
0306         struct impl
0307         {
0308             typedef RT result_type;
0309             impl(FP fp_)
0310                 : fp(fp_) {}
0311             template <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>
0312             RT operator()(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
0313             {
0314                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);
0315             }
0316             FP fp;
0317         };
0318     };
0319
0320
0321
0322
0323
0324
0325
0326     template <typename Dummy>
0327     struct function_ptr_impl<15, Dummy>
0328     {
0329         template <typename RT, typename FP>
0330         struct impl
0331         {
0332             typedef RT result_type;
0333             impl(FP fp_)
0334                 : fp(fp_) {}
0335             template <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>
0336             RT operator()(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
0337             {
0338                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);
0339             }
0340             FP fp;
0341         };
0342     };
0343
0344
0345
0346
0347
0348
0349
0350     template <typename Dummy>
0351     struct function_ptr_impl<16, Dummy>
0352     {
0353         template <typename RT, typename FP>
0354         struct impl
0355         {
0356             typedef RT result_type;
0357             impl(FP fp_)
0358                 : fp(fp_) {}
0359             template <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>
0360             RT operator()(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
0361             {
0362                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);
0363             }
0364             FP fp;
0365         };
0366     };
0367
0368
0369
0370
0371
0372
0373
0374     template <typename Dummy>
0375     struct function_ptr_impl<17, Dummy>
0376     {
0377         template <typename RT, typename FP>
0378         struct impl
0379         {
0380             typedef RT result_type;
0381             impl(FP fp_)
0382                 : fp(fp_) {}
0383             template <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>
0384             RT operator()(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
0385             {
0386                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);
0387             }
0388             FP fp;
0389         };
0390     };
0391
0392
0393
0394
0395
0396
0397
0398     template <typename Dummy>
0399     struct function_ptr_impl<18, Dummy>
0400     {
0401         template <typename RT, typename FP>
0402         struct impl
0403         {
0404             typedef RT result_type;
0405             impl(FP fp_)
0406                 : fp(fp_) {}
0407             template <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>
0408             RT operator()(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
0409             {
0410                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);
0411             }
0412             FP fp;
0413         };
0414     };
0415
0416
0417
0418
0419
0420
0421
0422     template <typename Dummy>
0423     struct function_ptr_impl<19, Dummy>
0424     {
0425         template <typename RT, typename FP>
0426         struct impl
0427         {
0428             typedef RT result_type;
0429             impl(FP fp_)
0430                 : fp(fp_) {}
0431             template <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>
0432             RT operator()(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
0433             {
0434                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);
0435             }
0436             FP fp;
0437         };
0438     };
0439
0440
0441
0442
0443
0444
0445
0446     template <typename Dummy>
0447     struct function_ptr_impl<20, Dummy>
0448     {
0449         template <typename RT, typename FP>
0450         struct impl
0451         {
0452             typedef RT result_type;
0453             impl(FP fp_)
0454                 : fp(fp_) {}
0455             template <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>
0456             RT operator()(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
0457             {
0458                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);
0459             }
0460             FP fp;
0461         };
0462     };