ceph/src/boost/libs/phoenix/include/boost/phoenix/bind/detail/cpp03/preprocessed/function_ptr_20.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     };