2 // bind/mem_fn_template.hpp
4 // Do not include this header directly
6 // Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
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)
12 // See http://www.boost.org/libs/bind/mem_fn.html for documentation.
15 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
16 # define BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
21 template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf0)
25 typedef R result_type;
26 typedef T * argument_type;
30 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ())
33 template<class U> R call(U & u, T const *) const
35 BOOST_MEM_FN_RETURN (u.*f_)();
38 template<class U> R call(U & u, void const *) const
40 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
45 explicit BOOST_MEM_FN_NAME(mf0)(F f): f_(f) {}
47 R operator()(T * p) const
49 BOOST_MEM_FN_RETURN (p->*f_)();
52 template<class U> R operator()(U & u) const
54 BOOST_MEM_FN_RETURN call(u, &u);
57 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
59 template<class U> R operator()(U const & u) const
61 BOOST_MEM_FN_RETURN call(u, &u);
66 R operator()(T & t) const
68 BOOST_MEM_FN_RETURN (t.*f_)();
71 bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
76 bool operator!=(BOOST_MEM_FN_NAME(mf0) const & rhs) const
84 template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf0)
88 typedef R result_type;
89 typedef T const * argument_type;
93 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const)
96 template<class U> R call(U & u, T const *) const
98 BOOST_MEM_FN_RETURN (u.*f_)();
101 template<class U> R call(U & u, void const *) const
103 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
108 explicit BOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {}
110 template<class U> R operator()(U const & u) const
112 BOOST_MEM_FN_RETURN call(u, &u);
115 R operator()(T const & t) const
117 BOOST_MEM_FN_RETURN (t.*f_)();
120 bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
125 bool operator!=(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
133 template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf1)
137 typedef R result_type;
138 typedef T * first_argument_type;
139 typedef A1 second_argument_type;
143 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
146 template<class U, class B1> R call(U & u, T const *, B1 & b1) const
148 BOOST_MEM_FN_RETURN (u.*f_)(b1);
151 template<class U, class B1> R call(U & u, void const *, B1 & b1) const
153 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
158 explicit BOOST_MEM_FN_NAME(mf1)(F f): f_(f) {}
160 R operator()(T * p, A1 a1) const
162 BOOST_MEM_FN_RETURN (p->*f_)(a1);
165 template<class U> R operator()(U & u, A1 a1) const
167 BOOST_MEM_FN_RETURN call(u, &u, a1);
170 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
172 template<class U> R operator()(U const & u, A1 a1) const
174 BOOST_MEM_FN_RETURN call(u, &u, a1);
179 R operator()(T & t, A1 a1) const
181 BOOST_MEM_FN_RETURN (t.*f_)(a1);
184 bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
189 bool operator!=(BOOST_MEM_FN_NAME(mf1) const & rhs) const
197 template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf1)
201 typedef R result_type;
202 typedef T const * first_argument_type;
203 typedef A1 second_argument_type;
207 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const)
210 template<class U, class B1> R call(U & u, T const *, B1 & b1) const
212 BOOST_MEM_FN_RETURN (u.*f_)(b1);
215 template<class U, class B1> R call(U & u, void const *, B1 & b1) const
217 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
222 explicit BOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {}
224 template<class U> R operator()(U const & u, A1 a1) const
226 BOOST_MEM_FN_RETURN call(u, &u, a1);
229 R operator()(T const & t, A1 a1) const
231 BOOST_MEM_FN_RETURN (t.*f_)(a1);
234 bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
239 bool operator!=(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
247 template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf2)
251 typedef R result_type;
255 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2))
258 template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
260 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
263 template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
265 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
270 explicit BOOST_MEM_FN_NAME(mf2)(F f): f_(f) {}
272 R operator()(T * p, A1 a1, A2 a2) const
274 BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
277 template<class U> R operator()(U & u, A1 a1, A2 a2) const
279 BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
282 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
284 template<class U> R operator()(U const & u, A1 a1, A2 a2) const
286 BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
291 R operator()(T & t, A1 a1, A2 a2) const
293 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
296 bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
301 bool operator!=(BOOST_MEM_FN_NAME(mf2) const & rhs) const
309 template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf2)
313 typedef R result_type;
317 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const)
320 template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
322 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
325 template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
327 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
332 explicit BOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {}
334 template<class U> R operator()(U const & u, A1 a1, A2 a2) const
336 BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
339 R operator()(T const & t, A1 a1, A2 a2) const
341 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
344 bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
349 bool operator!=(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
357 template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf3)
361 typedef R result_type;
365 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3))
368 template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
370 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
373 template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
375 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
380 explicit BOOST_MEM_FN_NAME(mf3)(F f): f_(f) {}
382 R operator()(T * p, A1 a1, A2 a2, A3 a3) const
384 BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
387 template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
389 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
392 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
394 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
396 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
401 R operator()(T & t, A1 a1, A2 a2, A3 a3) const
403 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
406 bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
411 bool operator!=(BOOST_MEM_FN_NAME(mf3) const & rhs) const
419 template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf3)
423 typedef R result_type;
427 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
430 template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
432 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
435 template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
437 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
442 explicit BOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {}
444 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
446 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
449 R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
451 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
454 bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
459 bool operator!=(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
467 template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf4)
471 typedef R result_type;
475 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
478 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
480 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
483 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
485 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
490 explicit BOOST_MEM_FN_NAME(mf4)(F f): f_(f) {}
492 R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
494 BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
497 template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
499 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
502 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
504 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
506 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
511 R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
513 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
516 bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
521 bool operator!=(BOOST_MEM_FN_NAME(mf4) const & rhs) const
529 template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf4)
533 typedef R result_type;
537 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
540 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
542 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
545 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
547 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
552 explicit BOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {}
554 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
556 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
559 R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
561 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
564 bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
569 bool operator!=(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
577 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)
581 typedef R result_type;
585 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
588 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
590 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
593 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
595 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
600 explicit BOOST_MEM_FN_NAME(mf5)(F f): f_(f) {}
602 R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
604 BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
607 template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
609 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
612 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
614 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
616 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
621 R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
623 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
626 bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
631 bool operator!=(BOOST_MEM_FN_NAME(mf5) const & rhs) const
639 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)
643 typedef R result_type;
647 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
650 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
652 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
655 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
657 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
662 explicit BOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {}
664 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
666 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
669 R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
671 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
674 bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
679 bool operator!=(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
687 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)
691 typedef R result_type;
695 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
698 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
700 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
703 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
705 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
710 explicit BOOST_MEM_FN_NAME(mf6)(F f): f_(f) {}
712 R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
714 BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
717 template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
719 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
722 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
724 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
726 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
731 R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
733 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
736 bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
741 bool operator!=(BOOST_MEM_FN_NAME(mf6) const & rhs) const
749 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)
753 typedef R result_type;
757 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
760 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
762 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
765 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
767 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
772 explicit BOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {}
774 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
776 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
779 R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
781 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
784 bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
789 bool operator!=(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
797 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)
801 typedef R result_type;
805 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
808 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
810 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
813 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
815 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
820 explicit BOOST_MEM_FN_NAME(mf7)(F f): f_(f) {}
822 R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
824 BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
827 template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
829 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
832 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
834 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
836 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
841 R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
843 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
846 bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
851 bool operator!=(BOOST_MEM_FN_NAME(mf7) const & rhs) const
859 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)
863 typedef R result_type;
867 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
870 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
872 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
875 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
877 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
882 explicit BOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {}
884 template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
886 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
889 R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
891 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
894 bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
899 bool operator!=(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
907 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)
911 typedef R result_type;
915 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
918 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
920 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
923 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
925 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
930 explicit BOOST_MEM_FN_NAME(mf8)(F f): f_(f) {}
932 R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
934 BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
937 template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
939 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
942 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
944 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
946 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
951 R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
953 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
956 bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
961 bool operator!=(BOOST_MEM_FN_NAME(mf8) const & rhs) const
969 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)
973 typedef R result_type;
977 BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
980 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
982 BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
985 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
987 BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
992 explicit BOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {}
994 R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
996 BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
999 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
1001 BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
1004 R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
1006 BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
1009 bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
1011 return f_ == rhs.f_;
1014 bool operator!=(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
1016 return f_ != rhs.f_;
1020 #undef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS