boost/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 //  Permission to copy, use, modify, sell and distribute this software
   9 //  is granted provided this copyright notice appears in all copies.
  10 //  This software is provided "as is" without express or implied
  11 //  warranty, and with no claim as to its suitability for any purpose.
  12 //
  13 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
  14 //
  15
  16 // mf0
  17
  18 template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf0)
  19 {
  20 public:
  21
  22     typedef R result_type;
  23     typedef T * argument_type;
  24
  25 private:
  26
  27     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ())
  28     F f_;
  29
  30     template<class U> R call(U & u, T const *) const
  31     {
  32         BOOST_MEM_FN_RETURN (u.*f_)();
  33     }
  34
  35     template<class U> R call(U & u, void const *) const
  36     {
  37         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
  38     }
  39
  40 public:
  41
  42     explicit BOOST_MEM_FN_NAME(mf0)(F f): f_(f) {}
  43
  44     R operator()(T * p) const
  45     {
  46         BOOST_MEM_FN_RETURN (p->*f_)();
  47     }
  48
  49     template<class U> R operator()(U & u) const
  50     {
  51         BOOST_MEM_FN_RETURN call(u, &u);
  52     }
  53
  54     R operator()(T & t) const
  55     {
  56         BOOST_MEM_FN_RETURN (t.*f_)();
  57     }
  58 };
  59
  60 // cmf0
  61
  62 template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf0)
  63 {
  64 public:
  65
  66     typedef R result_type;
  67     typedef T const * argument_type;
  68
  69 private:
  70
  71     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const)
  72     F f_;
  73
  74     template<class U> R call(U & u, T const *) const
  75     {
  76         BOOST_MEM_FN_RETURN (u.*f_)();
  77     }
  78
  79     template<class U> R call(U & u, void const *) const
  80     {
  81         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
  82     }
  83
  84 public:
  85
  86     explicit BOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {}
  87
  88     template<class U> R operator()(U const & u) const
  89     {
  90         BOOST_MEM_FN_RETURN call(u, &u);
  91     }
  92
  93     R operator()(T const & t) const
  94     {
  95         BOOST_MEM_FN_RETURN (t.*f_)();
  96     }
  97 };
  98
  99 // mf1
 100
 101 template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf1)
 102 {
 103 public:
 104
 105     typedef R result_type;
 106     typedef T * first_argument_type;
 107     typedef A1 second_argument_type;
 108
 109 private:
 110
 111     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
 112     F f_;
 113
 114     template<class U, class B1> R call(U & u, T const *, B1 & b1) const
 115     {
 116         BOOST_MEM_FN_RETURN (u.*f_)(b1);
 117     }
 118
 119     template<class U, class B1> R call(U & u, void const *, B1 & b1) const
 120     {
 121         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
 122     }
 123
 124 public:
 125
 126     explicit BOOST_MEM_FN_NAME(mf1)(F f): f_(f) {}
 127
 128     R operator()(T * p, A1 a1) const
 129     {
 130         BOOST_MEM_FN_RETURN (p->*f_)(a1);
 131     }
 132
 133     template<class U> R operator()(U & u, A1 a1) const
 134     {
 135         BOOST_MEM_FN_RETURN call(u, &u, a1);
 136     }
 137
 138     R operator()(T & t, A1 a1) const
 139     {
 140         BOOST_MEM_FN_RETURN (t.*f_)(a1);
 141     }
 142 };
 143
 144 // cmf1
 145
 146 template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf1)
 147 {
 148 public:
 149
 150     typedef R result_type;
 151     typedef T const * first_argument_type;
 152     typedef A1 second_argument_type;
 153
 154 private:
 155
 156     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const)
 157     F f_;
 158
 159     template<class U, class B1> R call(U & u, T const *, B1 & b1) const
 160     {
 161         BOOST_MEM_FN_RETURN (u.*f_)(b1);
 162     }
 163
 164     template<class U, class B1> R call(U & u, void const *, B1 & b1) const
 165     {
 166         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
 167     }
 168
 169 public:
 170
 171     explicit BOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {}
 172
 173     template<class U> R operator()(U const & u, A1 a1) const
 174     {
 175         BOOST_MEM_FN_RETURN call(u, &u, a1);
 176     }
 177
 178     R operator()(T const & t, A1 a1) const
 179     {
 180         BOOST_MEM_FN_RETURN (t.*f_)(a1);
 181     }
 182 };
 183
 184 // mf2
 185
 186 template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf2)
 187 {
 188 public:
 189
 190     typedef R result_type;
 191
 192 private:
 193
 194     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2))
 195     F f_;
 196
 197     template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
 198     {
 199         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
 200     }
 201
 202     template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
 203     {
 204         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
 205     }
 206
 207 public:
 208
 209     explicit BOOST_MEM_FN_NAME(mf2)(F f): f_(f) {}
 210
 211     R operator()(T * p, A1 a1, A2 a2) const
 212     {
 213         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
 214     }
 215
 216     template<class U> R operator()(U & u, A1 a1, A2 a2) const
 217     {
 218         BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
 219     }
 220
 221     R operator()(T & t, A1 a1, A2 a2) const
 222     {
 223         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
 224     }
 225 };
 226
 227 // cmf2
 228
 229 template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf2)
 230 {
 231 public:
 232
 233     typedef R result_type;
 234
 235 private:
 236
 237     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const)
 238     F f_;
 239
 240     template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
 241     {
 242         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
 243     }
 244
 245     template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
 246     {
 247         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
 248     }
 249
 250 public:
 251
 252     explicit BOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {}
 253
 254     template<class U> R operator()(U const & u, A1 a1, A2 a2) const
 255     {
 256         BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
 257     }
 258
 259     R operator()(T const & t, A1 a1, A2 a2) const
 260     {
 261         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
 262     }
 263 };
 264
 265 // mf3
 266
 267 template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf3)
 268 {
 269 public:
 270
 271     typedef R result_type;
 272
 273 private:
 274
 275     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3))
 276     F f_;
 277
 278     template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
 279     {
 280         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
 281     }
 282
 283     template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
 284     {
 285         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
 286     }
 287
 288 public:
 289
 290     explicit BOOST_MEM_FN_NAME(mf3)(F f): f_(f) {}
 291
 292     R operator()(T * p, A1 a1, A2 a2, A3 a3) const
 293     {
 294         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
 295     }
 296
 297     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
 298     {
 299         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
 300     }
 301
 302     R operator()(T & t, A1 a1, A2 a2, A3 a3) const
 303     {
 304         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
 305     }
 306 };
 307
 308 // cmf3
 309
 310 template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf3)
 311 {
 312 public:
 313
 314     typedef R result_type;
 315
 316 private:
 317
 318     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
 319     F f_;
 320
 321     template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
 322     {
 323         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
 324     }
 325
 326     template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
 327     {
 328         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
 329     }
 330
 331 public:
 332
 333     explicit BOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {}
 334
 335     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
 336     {
 337         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
 338     }
 339
 340     R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
 341     {
 342         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
 343     }
 344 };
 345
 346 // mf4
 347
 348 template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf4)
 349 {
 350 public:
 351
 352     typedef R result_type;
 353
 354 private:
 355
 356     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
 357     F f_;
 358
 359     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
 360     {
 361         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
 362     }
 363
 364     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
 365     {
 366         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
 367     }
 368
 369 public:
 370
 371     explicit BOOST_MEM_FN_NAME(mf4)(F f): f_(f) {}
 372
 373     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
 374     {
 375         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
 376     }
 377
 378     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
 379     {
 380         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
 381     }
 382
 383     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
 384     {
 385         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
 386     }
 387 };
 388
 389 // cmf4
 390
 391 template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf4)
 392 {
 393 public:
 394
 395     typedef R result_type;
 396
 397 private:
 398
 399     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
 400     F f_;
 401
 402     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
 403     {
 404         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
 405     }
 406
 407     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
 408     {
 409         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
 410     }
 411
 412 public:
 413
 414     explicit BOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {}
 415
 416     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
 417     {
 418         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
 419     }
 420
 421     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
 422     {
 423         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
 424     }
 425 };
 426
 427 // mf5
 428
 429 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)
 430 {
 431 public:
 432
 433     typedef R result_type;
 434
 435 private:
 436
 437     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
 438     F f_;
 439
 440     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
 441     {
 442         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
 443     }
 444
 445     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
 446     {
 447         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
 448     }
 449
 450 public:
 451
 452     explicit BOOST_MEM_FN_NAME(mf5)(F f): f_(f) {}
 453
 454     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 455     {
 456         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
 457     }
 458
 459     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 460     {
 461         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
 462     }
 463
 464     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 465     {
 466         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
 467     }
 468 };
 469
 470 // cmf5
 471
 472 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)
 473 {
 474 public:
 475
 476     typedef R result_type;
 477
 478 private:
 479
 480     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
 481     F f_;
 482
 483     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
 484     {
 485         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
 486     }
 487
 488     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
 489     {
 490         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
 491     }
 492
 493 public:
 494
 495     explicit BOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {}
 496
 497     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 498     {
 499         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
 500     }
 501
 502     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
 503     {
 504         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
 505     }
 506 };
 507
 508 // mf6
 509
 510 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)
 511 {
 512 public:
 513
 514     typedef R result_type;
 515
 516 private:
 517
 518     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
 519     F f_;
 520
 521     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
 522     {
 523         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
 524     }
 525
 526     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
 527     {
 528         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
 529     }
 530
 531 public:
 532
 533     explicit BOOST_MEM_FN_NAME(mf6)(F f): f_(f) {}
 534
 535     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 536     {
 537         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
 538     }
 539
 540     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 541     {
 542         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
 543     }
 544
 545     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 546     {
 547         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
 548     }
 549 };
 550
 551 // cmf6
 552
 553 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)
 554 {
 555 public:
 556
 557     typedef R result_type;
 558
 559 private:
 560
 561     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
 562     F f_;
 563
 564     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
 565     {
 566         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
 567     }
 568
 569     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
 570     {
 571         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
 572     }
 573
 574 public:
 575
 576     explicit BOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {}
 577
 578     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 579     {
 580         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
 581     }
 582
 583     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
 584     {
 585         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
 586     }
 587 };
 588
 589 // mf7
 590
 591 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)
 592 {
 593 public:
 594
 595     typedef R result_type;
 596
 597 private:
 598
 599     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
 600     F f_;
 601
 602     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
 603     {
 604         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
 605     }
 606
 607     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
 608     {
 609         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
 610     }
 611
 612 public:
 613
 614     explicit BOOST_MEM_FN_NAME(mf7)(F f): f_(f) {}
 615
 616     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 617     {
 618         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
 619     }
 620
 621     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 622     {
 623         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
 624     }
 625
 626     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 627     {
 628         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
 629     }
 630 };
 631
 632 // cmf7
 633
 634 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)
 635 {
 636 public:
 637
 638     typedef R result_type;
 639
 640 private:
 641
 642     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
 643     F f_;
 644
 645     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
 646     {
 647         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
 648     }
 649
 650     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
 651     {
 652         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
 653     }
 654
 655 public:
 656
 657     explicit BOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {}
 658
 659     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 660     {
 661         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
 662     }
 663
 664     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
 665     {
 666         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
 667     }
 668 };
 669
 670 // mf8
 671
 672 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)
 673 {
 674 public:
 675
 676     typedef R result_type;
 677
 678 private:
 679
 680     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
 681     F f_;
 682
 683     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
 684     {
 685         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
 686     }
 687
 688     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
 689     {
 690         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
 691     }
 692
 693 public:
 694
 695     explicit BOOST_MEM_FN_NAME(mf8)(F f): f_(f) {}
 696
 697     R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 698     {
 699         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
 700     }
 701
 702     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 703     {
 704         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
 705     }
 706
 707     R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 708     {
 709         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
 710     }
 711 };
 712
 713 // cmf8
 714
 715 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)
 716 {
 717 public:
 718
 719     typedef R result_type;
 720
 721 private:
 722
 723     BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
 724     F f_;
 725
 726     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
 727     {
 728         BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
 729     }
 730
 731     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
 732     {
 733         BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
 734     }
 735
 736 public:
 737
 738     explicit BOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {}
 739
 740     R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 741     {
 742         BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
 743     }
 744
 745     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
 746     {
 747         BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
 748     }
 749
 750     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
 751     {
 752         BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
 753     }
 754 };
 755