cpp03/preprocessed/function_ptr_30.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     };
0463
0464
0465
0466
0467
0468
0469
0470     template <typename Dummy>
0471     struct function_ptr_impl<21, Dummy>
0472     {
0473         template <typename RT, typename FP>
0474         struct impl
0475         {
0476             typedef RT result_type;
0477             impl(FP fp_)
0478                 : fp(fp_) {}
0479             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 , typename A20>
0480             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 , A20 & a20) const
0481             {
0482                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20);
0483             }
0484             FP fp;
0485         };
0486     };
0487
0488
0489
0490
0491
0492
0493
0494     template <typename Dummy>
0495     struct function_ptr_impl<22, Dummy>
0496     {
0497         template <typename RT, typename FP>
0498         struct impl
0499         {
0500             typedef RT result_type;
0501             impl(FP fp_)
0502                 : fp(fp_) {}
0503             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 , typename A20 , typename A21>
0504             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 , A20 & a20 , A21 & a21) const
0505             {
0506                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21);
0507             }
0508             FP fp;
0509         };
0510     };
0511
0512
0513
0514
0515
0516
0517
0518     template <typename Dummy>
0519     struct function_ptr_impl<23, Dummy>
0520     {
0521         template <typename RT, typename FP>
0522         struct impl
0523         {
0524             typedef RT result_type;
0525             impl(FP fp_)
0526                 : fp(fp_) {}
0527             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 , typename A20 , typename A21 , typename A22>
0528             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 , A20 & a20 , A21 & a21 , A22 & a22) const
0529             {
0530                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22);
0531             }
0532             FP fp;
0533         };
0534     };
0535
0536
0537
0538
0539
0540
0541
0542     template <typename Dummy>
0543     struct function_ptr_impl<24, Dummy>
0544     {
0545         template <typename RT, typename FP>
0546         struct impl
0547         {
0548             typedef RT result_type;
0549             impl(FP fp_)
0550                 : fp(fp_) {}
0551             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 , typename A20 , typename A21 , typename A22 , typename A23>
0552             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23) const
0553             {
0554                 return 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);
0555             }
0556             FP fp;
0557         };
0558     };
0559
0560
0561
0562
0563
0564
0565
0566     template <typename Dummy>
0567     struct function_ptr_impl<25, Dummy>
0568     {
0569         template <typename RT, typename FP>
0570         struct impl
0571         {
0572             typedef RT result_type;
0573             impl(FP fp_)
0574                 : fp(fp_) {}
0575             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24>
0576             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24) const
0577             {
0578                 return 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);
0579             }
0580             FP fp;
0581         };
0582     };
0583
0584
0585
0586
0587
0588
0589
0590     template <typename Dummy>
0591     struct function_ptr_impl<26, Dummy>
0592     {
0593         template <typename RT, typename FP>
0594         struct impl
0595         {
0596             typedef RT result_type;
0597             impl(FP fp_)
0598                 : fp(fp_) {}
0599             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25>
0600             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25) const
0601             {
0602                 return 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);
0603             }
0604             FP fp;
0605         };
0606     };
0607
0608
0609
0610
0611
0612
0613
0614     template <typename Dummy>
0615     struct function_ptr_impl<27, Dummy>
0616     {
0617         template <typename RT, typename FP>
0618         struct impl
0619         {
0620             typedef RT result_type;
0621             impl(FP fp_)
0622                 : fp(fp_) {}
0623             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26>
0624             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26) const
0625             {
0626                 return 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);
0627             }
0628             FP fp;
0629         };
0630     };
0631
0632
0633
0634
0635
0636
0637
0638     template <typename Dummy>
0639     struct function_ptr_impl<28, Dummy>
0640     {
0641         template <typename RT, typename FP>
0642         struct impl
0643         {
0644             typedef RT result_type;
0645             impl(FP fp_)
0646                 : fp(fp_) {}
0647             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27>
0648             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27) const
0649             {
0650                 return 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);
0651             }
0652             FP fp;
0653         };
0654     };
0655
0656
0657
0658
0659
0660
0661
0662     template <typename Dummy>
0663     struct function_ptr_impl<29, Dummy>
0664     {
0665         template <typename RT, typename FP>
0666         struct impl
0667         {
0668             typedef RT result_type;
0669             impl(FP fp_)
0670                 : fp(fp_) {}
0671             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28>
0672             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28) const
0673             {
0674                 return 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);
0675             }
0676             FP fp;
0677         };
0678     };
0679
0680
0681
0682
0683
0684
0685
0686     template <typename Dummy>
0687     struct function_ptr_impl<30, Dummy>
0688     {
0689         template <typename RT, typename FP>
0690         struct impl
0691         {
0692             typedef RT result_type;
0693             impl(FP fp_)
0694                 : fp(fp_) {}
0695             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 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29>
0696             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 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29) const
0697             {
0698                 return 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);
0699             }
0700             FP fp;
0701         };
0702     };