stc/exp/ml_stc_linux_make_v1.0/include/boost/bind/mem_fn_template.hpp

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