ceph/src/boost/boost/phoenix/bind/detail/cpp03/preprocessed/function_ptr_30.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2007 Joel de Guzman
   3
   4     Distributed under the Boost Software License, Version 1.0. (See accompanying
   5     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 ==============================================================================*/
   7
   8
   9
  10
  11
  12
  13
  14     template <typename Dummy>
  15     struct function_ptr_impl<2, Dummy>
  16     {
  17         template <typename RT, typename FP>
  18         struct impl
  19         {
  20             typedef RT result_type;
  21             impl(FP fp_)
  22                 : fp(fp_) {}
  23             template <typename A0 , typename A1>
  24             RT operator()(A0 & a0 , A1 & a1) const
  25             {
  26                 return fp(a0 , a1);
  27             }
  28             FP fp;
  29         };
  30     };
  31
  32
  33
  34
  35
  36
  37
  38     template <typename Dummy>
  39     struct function_ptr_impl<3, Dummy>
  40     {
  41         template <typename RT, typename FP>
  42         struct impl
  43         {
  44             typedef RT result_type;
  45             impl(FP fp_)
  46                 : fp(fp_) {}
  47             template <typename A0 , typename A1 , typename A2>
  48             RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const
  49             {
  50                 return fp(a0 , a1 , a2);
  51             }
  52             FP fp;
  53         };
  54     };
  55
  56
  57
  58
  59
  60
  61
  62     template <typename Dummy>
  63     struct function_ptr_impl<4, Dummy>
  64     {
  65         template <typename RT, typename FP>
  66         struct impl
  67         {
  68             typedef RT result_type;
  69             impl(FP fp_)
  70                 : fp(fp_) {}
  71             template <typename A0 , typename A1 , typename A2 , typename A3>
  72             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const
  73             {
  74                 return fp(a0 , a1 , a2 , a3);
  75             }
  76             FP fp;
  77         };
  78     };
  79
  80
  81
  82
  83
  84
  85
  86     template <typename Dummy>
  87     struct function_ptr_impl<5, Dummy>
  88     {
  89         template <typename RT, typename FP>
  90         struct impl
  91         {
  92             typedef RT result_type;
  93             impl(FP fp_)
  94                 : fp(fp_) {}
  95             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
  96             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const
  97             {
  98                 return fp(a0 , a1 , a2 , a3 , a4);
  99             }
 100             FP fp;
 101         };
 102     };
 103
 104
 105
 106
 107
 108
 109
 110     template <typename Dummy>
 111     struct function_ptr_impl<6, Dummy>
 112     {
 113         template <typename RT, typename FP>
 114         struct impl
 115         {
 116             typedef RT result_type;
 117             impl(FP fp_)
 118                 : fp(fp_) {}
 119             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 120             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const
 121             {
 122                 return fp(a0 , a1 , a2 , a3 , a4 , a5);
 123             }
 124             FP fp;
 125         };
 126     };
 127
 128
 129
 130
 131
 132
 133
 134     template <typename Dummy>
 135     struct function_ptr_impl<7, Dummy>
 136     {
 137         template <typename RT, typename FP>
 138         struct impl
 139         {
 140             typedef RT result_type;
 141             impl(FP fp_)
 142                 : fp(fp_) {}
 143             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 144             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const
 145             {
 146                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);
 147             }
 148             FP fp;
 149         };
 150     };
 151
 152
 153
 154
 155
 156
 157
 158     template <typename Dummy>
 159     struct function_ptr_impl<8, Dummy>
 160     {
 161         template <typename RT, typename FP>
 162         struct impl
 163         {
 164             typedef RT result_type;
 165             impl(FP fp_)
 166                 : fp(fp_) {}
 167             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 168             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const
 169             {
 170                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
 171             }
 172             FP fp;
 173         };
 174     };
 175
 176
 177
 178
 179
 180
 181
 182     template <typename Dummy>
 183     struct function_ptr_impl<9, Dummy>
 184     {
 185         template <typename RT, typename FP>
 186         struct impl
 187         {
 188             typedef RT result_type;
 189             impl(FP fp_)
 190                 : fp(fp_) {}
 191             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
 192             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const
 193             {
 194                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
 195             }
 196             FP fp;
 197         };
 198     };
 199
 200
 201
 202
 203
 204
 205
 206     template <typename Dummy>
 207     struct function_ptr_impl<10, Dummy>
 208     {
 209         template <typename RT, typename FP>
 210         struct impl
 211         {
 212             typedef RT result_type;
 213             impl(FP fp_)
 214                 : fp(fp_) {}
 215             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
 216             RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const
 217             {
 218                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
 219             }
 220             FP fp;
 221         };
 222     };
 223
 224
 225
 226
 227
 228
 229
 230     template <typename Dummy>
 231     struct function_ptr_impl<11, Dummy>
 232     {
 233         template <typename RT, typename FP>
 234         struct impl
 235         {
 236             typedef RT result_type;
 237             impl(FP fp_)
 238                 : fp(fp_) {}
 239             template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
 240             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
 241             {
 242                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);
 243             }
 244             FP fp;
 245         };
 246     };
 247
 248
 249
 250
 251
 252
 253
 254     template <typename Dummy>
 255     struct function_ptr_impl<12, Dummy>
 256     {
 257         template <typename RT, typename FP>
 258         struct impl
 259         {
 260             typedef RT result_type;
 261             impl(FP fp_)
 262                 : fp(fp_) {}
 263             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>
 264             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
 265             {
 266                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);
 267             }
 268             FP fp;
 269         };
 270     };
 271
 272
 273
 274
 275
 276
 277
 278     template <typename Dummy>
 279     struct function_ptr_impl<13, Dummy>
 280     {
 281         template <typename RT, typename FP>
 282         struct impl
 283         {
 284             typedef RT result_type;
 285             impl(FP fp_)
 286                 : fp(fp_) {}
 287             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>
 288             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
 289             {
 290                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);
 291             }
 292             FP fp;
 293         };
 294     };
 295
 296
 297
 298
 299
 300
 301
 302     template <typename Dummy>
 303     struct function_ptr_impl<14, Dummy>
 304     {
 305         template <typename RT, typename FP>
 306         struct impl
 307         {
 308             typedef RT result_type;
 309             impl(FP fp_)
 310                 : fp(fp_) {}
 311             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>
 312             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
 313             {
 314                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);
 315             }
 316             FP fp;
 317         };
 318     };
 319
 320
 321
 322
 323
 324
 325
 326     template <typename Dummy>
 327     struct function_ptr_impl<15, Dummy>
 328     {
 329         template <typename RT, typename FP>
 330         struct impl
 331         {
 332             typedef RT result_type;
 333             impl(FP fp_)
 334                 : fp(fp_) {}
 335             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>
 336             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
 337             {
 338                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);
 339             }
 340             FP fp;
 341         };
 342     };
 343
 344
 345
 346
 347
 348
 349
 350     template <typename Dummy>
 351     struct function_ptr_impl<16, Dummy>
 352     {
 353         template <typename RT, typename FP>
 354         struct impl
 355         {
 356             typedef RT result_type;
 357             impl(FP fp_)
 358                 : fp(fp_) {}
 359             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>
 360             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
 361             {
 362                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);
 363             }
 364             FP fp;
 365         };
 366     };
 367
 368
 369
 370
 371
 372
 373
 374     template <typename Dummy>
 375     struct function_ptr_impl<17, Dummy>
 376     {
 377         template <typename RT, typename FP>
 378         struct impl
 379         {
 380             typedef RT result_type;
 381             impl(FP fp_)
 382                 : fp(fp_) {}
 383             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>
 384             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
 385             {
 386                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);
 387             }
 388             FP fp;
 389         };
 390     };
 391
 392
 393
 394
 395
 396
 397
 398     template <typename Dummy>
 399     struct function_ptr_impl<18, Dummy>
 400     {
 401         template <typename RT, typename FP>
 402         struct impl
 403         {
 404             typedef RT result_type;
 405             impl(FP fp_)
 406                 : fp(fp_) {}
 407             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>
 408             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
 409             {
 410                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);
 411             }
 412             FP fp;
 413         };
 414     };
 415
 416
 417
 418
 419
 420
 421
 422     template <typename Dummy>
 423     struct function_ptr_impl<19, Dummy>
 424     {
 425         template <typename RT, typename FP>
 426         struct impl
 427         {
 428             typedef RT result_type;
 429             impl(FP fp_)
 430                 : fp(fp_) {}
 431             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>
 432             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
 433             {
 434                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);
 435             }
 436             FP fp;
 437         };
 438     };
 439
 440
 441
 442
 443
 444
 445
 446     template <typename Dummy>
 447     struct function_ptr_impl<20, Dummy>
 448     {
 449         template <typename RT, typename FP>
 450         struct impl
 451         {
 452             typedef RT result_type;
 453             impl(FP fp_)
 454                 : fp(fp_) {}
 455             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>
 456             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
 457             {
 458                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);
 459             }
 460             FP fp;
 461         };
 462     };
 463
 464
 465
 466
 467
 468
 469
 470     template <typename Dummy>
 471     struct function_ptr_impl<21, Dummy>
 472     {
 473         template <typename RT, typename FP>
 474         struct impl
 475         {
 476             typedef RT result_type;
 477             impl(FP fp_)
 478                 : fp(fp_) {}
 479             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>
 480             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
 481             {
 482                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20);
 483             }
 484             FP fp;
 485         };
 486     };
 487
 488
 489
 490
 491
 492
 493
 494     template <typename Dummy>
 495     struct function_ptr_impl<22, Dummy>
 496     {
 497         template <typename RT, typename FP>
 498         struct impl
 499         {
 500             typedef RT result_type;
 501             impl(FP fp_)
 502                 : fp(fp_) {}
 503             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>
 504             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
 505             {
 506                 return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21);
 507             }
 508             FP fp;
 509         };
 510     };
 511
 512
 513
 514
 515
 516
 517
 518     template <typename Dummy>
 519     struct function_ptr_impl<23, Dummy>
 520     {
 521         template <typename RT, typename FP>
 522         struct impl
 523         {
 524             typedef RT result_type;
 525             impl(FP fp_)
 526                 : fp(fp_) {}
 527             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>
 528             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
 529             {
 530                 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);
 531             }
 532             FP fp;
 533         };
 534     };
 535
 536
 537
 538
 539
 540
 541
 542     template <typename Dummy>
 543     struct function_ptr_impl<24, Dummy>
 544     {
 545         template <typename RT, typename FP>
 546         struct impl
 547         {
 548             typedef RT result_type;
 549             impl(FP fp_)
 550                 : fp(fp_) {}
 551             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>
 552             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
 553             {
 554                 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);
 555             }
 556             FP fp;
 557         };
 558     };
 559
 560
 561
 562
 563
 564
 565
 566     template <typename Dummy>
 567     struct function_ptr_impl<25, Dummy>
 568     {
 569         template <typename RT, typename FP>
 570         struct impl
 571         {
 572             typedef RT result_type;
 573             impl(FP fp_)
 574                 : fp(fp_) {}
 575             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>
 576             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
 577             {
 578                 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);
 579             }
 580             FP fp;
 581         };
 582     };
 583
 584
 585
 586
 587
 588
 589
 590     template <typename Dummy>
 591     struct function_ptr_impl<26, Dummy>
 592     {
 593         template <typename RT, typename FP>
 594         struct impl
 595         {
 596             typedef RT result_type;
 597             impl(FP fp_)
 598                 : fp(fp_) {}
 599             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>
 600             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
 601             {
 602                 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);
 603             }
 604             FP fp;
 605         };
 606     };
 607
 608
 609
 610
 611
 612
 613
 614     template <typename Dummy>
 615     struct function_ptr_impl<27, Dummy>
 616     {
 617         template <typename RT, typename FP>
 618         struct impl
 619         {
 620             typedef RT result_type;
 621             impl(FP fp_)
 622                 : fp(fp_) {}
 623             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>
 624             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
 625             {
 626                 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);
 627             }
 628             FP fp;
 629         };
 630     };
 631
 632
 633
 634
 635
 636
 637
 638     template <typename Dummy>
 639     struct function_ptr_impl<28, Dummy>
 640     {
 641         template <typename RT, typename FP>
 642         struct impl
 643         {
 644             typedef RT result_type;
 645             impl(FP fp_)
 646                 : fp(fp_) {}
 647             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>
 648             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
 649             {
 650                 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);
 651             }
 652             FP fp;
 653         };
 654     };
 655
 656
 657
 658
 659
 660
 661
 662     template <typename Dummy>
 663     struct function_ptr_impl<29, Dummy>
 664     {
 665         template <typename RT, typename FP>
 666         struct impl
 667         {
 668             typedef RT result_type;
 669             impl(FP fp_)
 670                 : fp(fp_) {}
 671             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>
 672             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
 673             {
 674                 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);
 675             }
 676             FP fp;
 677         };
 678     };
 679
 680
 681
 682
 683
 684
 685
 686     template <typename Dummy>
 687     struct function_ptr_impl<30, Dummy>
 688     {
 689         template <typename RT, typename FP>
 690         struct impl
 691         {
 692             typedef RT result_type;
 693             impl(FP fp_)
 694                 : fp(fp_) {}
 695             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>
 696             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
 697             {
 698                 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);
 699             }
 700             FP fp;
 701         };
 702     };