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 1048
