ceph/src/boost/libs/bind/include/boost/bind/mem_fn_template.hpp

   1 //
   2 //  bind/mem_fn_template.hpp
   3 //
   4 //  Do not include this header directly
   5 //
   6 //  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
   7 //
   8 // Distributed under the Boost Software License, Version 1.0. (See
   9 // accompanying file LICENSE_1_0.txt or copy at
  10 // http://www.boost.org/LICENSE_1_0.txt)
  11 //
  12 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
  13 //
  14
  15 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
  16 # define BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
  17 #endif
  18
  19 // mf0
  20
  21 template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf0)
  22 {
  23 public:
  24
  25     typedef R result_type;
  26     typedef T * argument_type;
  27
  28 private:
  29
  30     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ())
  31     F f_;
  32
  33     template<class U> R call(U & u, T const *) const
  34     {
  35         BOOST_MEM_FN_RETURN (u.*f_)();
  36     }
  37
  38     template<class U> R call(U & u, void const *) const
  39     {
  40         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
  41     }
  42
  43 public:
  44
  45     explicit BOOST_MEM_FN_NAME(mf0)(F f): f_(f) {}
  46
  47     R operator()(T * p) const
  48     {
  49         BOOST_MEM_FN_RETURN (p->*f_)();
  50     }
  51
  52     template<class U> R operator()(U & u) const
  53     {
  54         U const * p = 0;
  55         BOOST_MEM_FN_RETURN call(u, p);
  56     }
  57
  58 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
  59
  60     template<class U> R operator()(U const & u) const
  61     {
  62         U const * p = 0;
  63         BOOST_MEM_FN_RETURN call(u, p);
  64     }
  65
  66 #endif
  67
  68     R operator()(T & t) const
  69     {
  70         BOOST_MEM_FN_RETURN (t.*f_)();
  71     }
  72
  73     bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
  74     {
  75         return f_ == rhs.f_;
  76     }
  77
  78     bool operator!=(BOOST_MEM_FN_NAME(mf0) const & rhs) const
  79     {
  80         return f_ != rhs.f_;
  81     }
  82 };
  83
  84 // cmf0
  85
  86 template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf0)
  87 {
  88 public:
  89
  90     typedef R result_type;
  91     typedef T const * argument_type;
  92
  93 private:
  94
  95     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const)
  96     F f_;
  97
  98     template<class U> R call(U & u, T const *) const
  99     {
 100         BOOST_MEM_FN_RETURN (u.*f_)();
 101     }
 102
 103     template<class U> R call(U & u, void const *) const
 104     {
 105         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
 106     }
 107
 108 public:
 109
 110     explicit BOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {}
 111
 112     template<class U> R operator()(U const & u) const
 113     {
 114         U const * p = 0;
 115         BOOST_MEM_FN_RETURN call(u, p);
 116     }
 117
 118     R operator()(T const & t) const
 119     {
 120         BOOST_MEM_FN_RETURN (t.*f_)();
 121     }
 122
 123     bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
 124     {
 125         return f_ == rhs.f_;
 126     }
 127
 128     bool operator!=(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
 129     {
 130         return f_ != rhs.f_;
 131     }
 132 };
 133
 134 // mf1
 135
 136 template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf1)
 137 {
 138 public:
 139
 140     typedef R result_type;
 141     typedef T * first_argument_type;
 142     typedef A1 second_argument_type;
 143
 144 private:
 145
 146     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
 147     F f_;
 148
 149     template<class U, class B1> R call(U & u, T const *, B1 & b1) const
 150     {
 151         BOOST_MEM_FN_RETURN (u.*f_)(b1);
 152     }
 153
 154     template<class U, class B1> R call(U & u, void const *, B1 & b1) const
 155     {
 156         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
 157     }
 158
 159 public:
 160
 161     explicit BOOST_MEM_FN_NAME(mf1)(F f): f_(f) {}
 162
 163     R operator()(T * p, A1 a1) const
 164     {
 165         BOOST_MEM_FN_RETURN (p->*f_)(a1);
 166     }
 167
 168     template<class U> R operator()(U & u, A1 a1) const
 169     {
 170         U const * p = 0;
 171         BOOST_MEM_FN_RETURN call(u, p, a1);
 172     }
 173
 174 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 175
 176     template<class U> R operator()(U const & u, A1 a1) const
 177     {
 178         U const * p = 0;
 179         BOOST_MEM_FN_RETURN call(u, p, a1);
 180     }
 181
 182 #endif
 183
 184     R operator()(T & t, A1 a1) const
 185     {
 186         BOOST_MEM_FN_RETURN (t.*f_)(a1);
 187     }
 188
 189     bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
 190     {
 191         return f_ == rhs.f_;
 192     }
 193
 194     bool operator!=(BOOST_MEM_FN_NAME(mf1) const & rhs) const
 195     {
 196         return f_ != rhs.f_;
 197     }
 198 };
 199
 200 // cmf1
 201
 202 template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf1)
 203 {
 204 public:
 205
 206     typedef R result_type;
 207     typedef T const * first_argument_type;
 208     typedef A1 second_argument_type;
 209
 210 private:
 211
 212     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const)
 213     F f_;
 214
 215     template<class U, class B1> R call(U & u, T const *, B1 & b1) const
 216     {
 217         BOOST_MEM_FN_RETURN (u.*f_)(b1);
 218     }
 219
 220     template<class U, class B1> R call(U & u, void const *, B1 & b1) const
 221     {
 222         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
 223     }
 224
 225 public:
 226
 227     explicit BOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {}
 228
 229     template<class U> R operator()(U const & u, A1 a1) const
 230     {
 231         U const * p = 0;
 232         BOOST_MEM_FN_RETURN call(u, p, a1);
 233     }
 234
 235     R operator()(T const & t, A1 a1) const
 236     {
 237         BOOST_MEM_FN_RETURN (t.*f_)(a1);
 238     }
 239
 240     bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
 241     {
 242         return f_ == rhs.f_;
 243     }
 244
 245     bool operator!=(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
 246     {
 247         return f_ != rhs.f_;
 248     }
 249 };
 250
 251 // mf2
 252
 253 template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf2)
 254 {
 255 public:
 256
 257     typedef R result_type;
 258
 259 private:
 260
 261     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2))
 262     F f_;
 263
 264     template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
 265     {
 266         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
 267     }
 268
 269     template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
 270     {
 271         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
 272     }
 273
 274 public:
 275
 276     explicit BOOST_MEM_FN_NAME(mf2)(F f): f_(f) {}
 277
 278     R operator()(T * p, A1 a1, A2 a2) const
 279     {
 280         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
 281     }
 282
 283     template<class U> R operator()(U & u, A1 a1, A2 a2) const
 284     {
 285         U const * p = 0;
 286         BOOST_MEM_FN_RETURN call(u, p, a1, a2);
 287     }
 288
 289 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 290
 291     template<class U> R operator()(U const & u, A1 a1, A2 a2) const
 292     {
 293         U const * p = 0;
 294         BOOST_MEM_FN_RETURN call(u, p, a1, a2);
 295     }
 296
 297 #endif
 298
 299     R operator()(T & t, A1 a1, A2 a2) const
 300     {
 301         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
 302     }
 303
 304     bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
 305     {
 306         return f_ == rhs.f_;
 307     }
 308
 309     bool operator!=(BOOST_MEM_FN_NAME(mf2) const & rhs) const
 310     {
 311         return f_ != rhs.f_;
 312     }
 313 };
 314
 315 // cmf2
 316
 317 template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf2)
 318 {
 319 public:
 320
 321     typedef R result_type;
 322
 323 private:
 324
 325     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const)
 326     F f_;
 327
 328     template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
 329     {
 330         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
 331     }
 332
 333     template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
 334     {
 335         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
 336     }
 337
 338 public:
 339
 340     explicit BOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {}
 341
 342     template<class U> R operator()(U const & u, A1 a1, A2 a2) const
 343     {
 344         U const * p = 0;
 345         BOOST_MEM_FN_RETURN call(u, p, a1, a2);
 346     }
 347
 348     R operator()(T const & t, A1 a1, A2 a2) const
 349     {
 350         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
 351     }
 352
 353     bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
 354     {
 355         return f_ == rhs.f_;
 356     }
 357
 358     bool operator!=(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
 359     {
 360         return f_ != rhs.f_;
 361     }
 362 };
 363
 364 // mf3
 365
 366 template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf3)
 367 {
 368 public:
 369
 370     typedef R result_type;
 371
 372 private:
 373
 374     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3))
 375     F f_;
 376
 377     template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
 378     {
 379         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
 380     }
 381
 382     template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
 383     {
 384         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
 385     }
 386
 387 public:
 388
 389     explicit BOOST_MEM_FN_NAME(mf3)(F f): f_(f) {}
 390
 391     R operator()(T * p, A1 a1, A2 a2, A3 a3) const
 392     {
 393         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
 394     }
 395
 396     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
 397     {
 398         U const * p = 0;
 399         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
 400     }
 401
 402 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 403
 404     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
 405     {
 406         U const * p = 0;
 407         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
 408     }
 409
 410 #endif
 411
 412     R operator()(T & t, A1 a1, A2 a2, A3 a3) const
 413     {
 414         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
 415     }
 416
 417     bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
 418     {
 419         return f_ == rhs.f_;
 420     }
 421
 422     bool operator!=(BOOST_MEM_FN_NAME(mf3) const & rhs) const
 423     {
 424         return f_ != rhs.f_;
 425     }
 426 };
 427
 428 // cmf3
 429
 430 template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf3)
 431 {
 432 public:
 433
 434     typedef R result_type;
 435
 436 private:
 437
 438     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
 439     F f_;
 440
 441     template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
 442     {
 443         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
 444     }
 445
 446     template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
 447     {
 448         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
 449     }
 450
 451 public:
 452
 453     explicit BOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {}
 454
 455     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
 456     {
 457         U const * p = 0;
 458         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
 459     }
 460
 461     R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
 462     {
 463         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
 464     }
 465
 466     bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
 467     {
 468         return f_ == rhs.f_;
 469     }
 470
 471     bool operator!=(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
 472     {
 473         return f_ != rhs.f_;
 474     }
 475 };
 476
 477 // mf4
 478
 479 template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf4)
 480 {
 481 public:
 482
 483     typedef R result_type;
 484
 485 private:
 486
 487     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
 488     F f_;
 489
 490     template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
 491     {
 492         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
 493     }
 494
 495     template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
 496     {
 497         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
 498     }
 499
 500 public:
 501
 502     explicit BOOST_MEM_FN_NAME(mf4)(F f): f_(f) {}
 503
 504     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
 505     {
 506         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
 507     }
 508
 509     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
 510     {
 511         U const * p = 0;
 512         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
 513     }
 514
 515 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 516
 517     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
 518     {
 519         U const * p = 0;
 520         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
 521     }
 522
 523 #endif
 524
 525     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
 526     {
 527         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
 528     }
 529
 530     bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
 531     {
 532         return f_ == rhs.f_;
 533     }
 534
 535     bool operator!=(BOOST_MEM_FN_NAME(mf4) const & rhs) const
 536     {
 537         return f_ != rhs.f_;
 538     }
 539 };
 540
 541 // cmf4
 542
 543 template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf4)
 544 {
 545 public:
 546
 547     typedef R result_type;
 548
 549 private:
 550
 551     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
 552     F f_;
 553
 554     template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
 555     {
 556         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
 557     }
 558
 559     template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
 560     {
 561         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
 562     }
 563
 564 public:
 565
 566     explicit BOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {}
 567
 568     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
 569     {
 570         U const * p = 0;
 571         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
 572     }
 573
 574     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
 575     {
 576         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
 577     }
 578
 579     bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
 580     {
 581         return f_ == rhs.f_;
 582     }
 583
 584     bool operator!=(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
 585     {
 586         return f_ != rhs.f_;
 587     }
 588 };
 589
 590 // mf5
 591
 592 template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf5)
 593 {
 594 public:
 595
 596     typedef R result_type;
 597
 598 private:
 599
 600     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
 601     F f_;
 602
 603     template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
 604     {
 605         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
 606     }
 607
 608     template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
 609     {
 610         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
 611     }
 612
 613 public:
 614
 615     explicit BOOST_MEM_FN_NAME(mf5)(F f): f_(f) {}
 616
 617     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 618     {
 619         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
 620     }
 621
 622     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 623     {
 624         U const * p = 0;
 625         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
 626     }
 627
 628 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 629
 630     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 631     {
 632         U const * p = 0;
 633         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
 634     }
 635
 636 #endif
 637
 638     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 639     {
 640         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
 641     }
 642
 643     bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
 644     {
 645         return f_ == rhs.f_;
 646     }
 647
 648     bool operator!=(BOOST_MEM_FN_NAME(mf5) const & rhs) const
 649     {
 650         return f_ != rhs.f_;
 651     }
 652 };
 653
 654 // cmf5
 655
 656 template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf5)
 657 {
 658 public:
 659
 660     typedef R result_type;
 661
 662 private:
 663
 664     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
 665     F f_;
 666
 667     template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
 668     {
 669         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
 670     }
 671
 672     template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
 673     {
 674         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
 675     }
 676
 677 public:
 678
 679     explicit BOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {}
 680
 681     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 682     {
 683         U const * p = 0;
 684         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
 685     }
 686
 687     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 688     {
 689         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
 690     }
 691
 692     bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
 693     {
 694         return f_ == rhs.f_;
 695     }
 696
 697     bool operator!=(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
 698     {
 699         return f_ != rhs.f_;
 700     }
 701 };
 702
 703 // mf6
 704
 705 template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf6)
 706 {
 707 public:
 708
 709     typedef R result_type;
 710
 711 private:
 712
 713     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
 714     F f_;
 715
 716     template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
 717     {
 718         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
 719     }
 720
 721     template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
 722     {
 723         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
 724     }
 725
 726 public:
 727
 728     explicit BOOST_MEM_FN_NAME(mf6)(F f): f_(f) {}
 729
 730     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 731     {
 732         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
 733     }
 734
 735     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 736     {
 737         U const * p = 0;
 738         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
 739     }
 740
 741 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 742
 743     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 744     {
 745         U const * p = 0;
 746         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
 747     }
 748
 749 #endif
 750
 751     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 752     {
 753         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
 754     }
 755
 756     bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
 757     {
 758         return f_ == rhs.f_;
 759     }
 760
 761     bool operator!=(BOOST_MEM_FN_NAME(mf6) const & rhs) const
 762     {
 763         return f_ != rhs.f_;
 764     }
 765 };
 766
 767 // cmf6
 768
 769 template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf6)
 770 {
 771 public:
 772
 773     typedef R result_type;
 774
 775 private:
 776
 777     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
 778     F f_;
 779
 780     template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
 781     {
 782         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
 783     }
 784
 785     template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
 786     {
 787         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
 788     }
 789
 790 public:
 791
 792     explicit BOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {}
 793
 794     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 795     {
 796         U const * p = 0;
 797         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
 798     }
 799
 800     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 801     {
 802         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
 803     }
 804
 805     bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
 806     {
 807         return f_ == rhs.f_;
 808     }
 809
 810     bool operator!=(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
 811     {
 812         return f_ != rhs.f_;
 813     }
 814 };
 815
 816 // mf7
 817
 818 template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf7)
 819 {
 820 public:
 821
 822     typedef R result_type;
 823
 824 private:
 825
 826     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
 827     F f_;
 828
 829     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
 830     {
 831         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
 832     }
 833
 834     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
 835     {
 836         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
 837     }
 838
 839 public:
 840
 841     explicit BOOST_MEM_FN_NAME(mf7)(F f): f_(f) {}
 842
 843     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 844     {
 845         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
 846     }
 847
 848     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 849     {
 850         U const * p = 0;
 851         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
 852     }
 853
 854 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 855
 856     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 857     {
 858         U const * p = 0;
 859         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
 860     }
 861
 862 #endif
 863
 864     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 865     {
 866         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
 867     }
 868
 869     bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
 870     {
 871         return f_ == rhs.f_;
 872     }
 873
 874     bool operator!=(BOOST_MEM_FN_NAME(mf7) const & rhs) const
 875     {
 876         return f_ != rhs.f_;
 877     }
 878 };
 879
 880 // cmf7
 881
 882 template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf7)
 883 {
 884 public:
 885
 886     typedef R result_type;
 887
 888 private:
 889
 890     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
 891     F f_;
 892
 893     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
 894     {
 895         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
 896     }
 897
 898     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
 899     {
 900         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
 901     }
 902
 903 public:
 904
 905     explicit BOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {}
 906
 907     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 908     {
 909         U const * p = 0;
 910         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
 911     }
 912
 913     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 914     {
 915         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
 916     }
 917
 918     bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
 919     {
 920         return f_ == rhs.f_;
 921     }
 922
 923     bool operator!=(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
 924     {
 925         return f_ != rhs.f_;
 926     }
 927 };
 928
 929 // mf8
 930
 931 template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf8)
 932 {
 933 public:
 934
 935     typedef R result_type;
 936
 937 private:
 938
 939     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
 940     F f_;
 941
 942     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
 943     {
 944         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
 945     }
 946
 947     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
 948     {
 949         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
 950     }
 951
 952 public:
 953
 954     explicit BOOST_MEM_FN_NAME(mf8)(F f): f_(f) {}
 955
 956     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 957     {
 958         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
 959     }
 960
 961     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 962     {
 963         U const * p = 0;
 964         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
 965     }
 966
 967 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 968
 969     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 970     {
 971         U const * p = 0;
 972         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
 973     }
 974
 975 #endif
 976
 977     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 978     {
 979         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
 980     }
 981
 982     bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
 983     {
 984         return f_ == rhs.f_;
 985     }
 986
 987     bool operator!=(BOOST_MEM_FN_NAME(mf8) const & rhs) const
 988     {
 989         return f_ != rhs.f_;
 990     }
 991 };
 992
 993 // cmf8
 994
 995 template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf8)
 996 {
 997 public:
 998
 999     typedef R result_type;
1000
1001 private:
1002
1003     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
1004     F f_;
1005
1006     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
1007     {
1008         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
1009     }
1010
1011     template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
1012     {
1013         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
1014     }
1015
1016 public:
1017
1018     explicit BOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {}
1019
1020     R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
1021     {
1022         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
1023     }
1024
1025     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
1026     {
1027         U const * p = 0;
1028         BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
1029     }
1030
1031     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
1032     {
1033         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
1034     }
1035
1036     bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
1037     {
1038         return f_ == rhs.f_;
1039     }
1040
1041     bool operator!=(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
1042     {
1043         return f_ != rhs.f_;
1044     }
1045 };
1046
1047 #undef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS