From 645d30d455217ef73e9b6e68546f9039f1747cc9 Mon Sep 17 00:00:00 2001 From: Peter Dimov Date: Tue, 2 Jan 2024 19:55:36 +0200 Subject: [PATCH] Remove unnecessary macros from mem_fn.hpp --- include/boost/bind/mem_fn.hpp | 10 - include/boost/bind/mem_fn_template.hpp | 254 ++++++++++++------------- 2 files changed, 127 insertions(+), 137 deletions(-) diff --git a/include/boost/bind/mem_fn.hpp b/include/boost/bind/mem_fn.hpp index c0a1a8f..6f9fbb3 100644 --- a/include/boost/bind/mem_fn.hpp +++ b/include/boost/bind/mem_fn.hpp @@ -29,14 +29,9 @@ namespace boost { -#define BOOST_MEM_FN_CLASS_F -#define BOOST_MEM_FN_TYPEDEF(X) typedef X; - namespace _mfi { -#define BOOST_MEM_FN_RETURN return - #define BOOST_MEM_FN_NAME(X) X #define BOOST_MEM_FN_CC @@ -81,13 +76,8 @@ namespace _mfi #endif -#undef BOOST_MEM_FN_RETURN - } // namespace _mfi -#undef BOOST_MEM_FN_CLASS_F -#undef BOOST_MEM_FN_TYPEDEF - // #define BOOST_MEM_FN_NAME(X) X diff --git a/include/boost/bind/mem_fn_template.hpp b/include/boost/bind/mem_fn_template.hpp index b26d585..f305e42 100644 --- a/include/boost/bind/mem_fn_template.hpp +++ b/include/boost/bind/mem_fn_template.hpp @@ -18,7 +18,7 @@ // mf0 -template class BOOST_MEM_FN_NAME(mf0) +template class BOOST_MEM_FN_NAME(mf0) { public: @@ -27,17 +27,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ()) + typedef R (BOOST_MEM_FN_CC T::*F) (); F f_; template R call(U & u, T const *) const { - BOOST_MEM_FN_RETURN (u.*f_)(); + return (u.*f_)(); } template R call(U & u, void const *) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(); + return (get_pointer(u)->*f_)(); } public: @@ -46,13 +46,13 @@ public: R operator()(T * p) const { - BOOST_MEM_FN_RETURN (p->*f_)(); + return (p->*f_)(); } template R operator()(U & u) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p); + return call(u, p); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -60,14 +60,14 @@ public: template R operator()(U const & u) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p); + return call(u, p); } #endif R operator()(T & t) const { - BOOST_MEM_FN_RETURN (t.*f_)(); + return (t.*f_)(); } bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const @@ -83,7 +83,7 @@ public: // cmf0 -template class BOOST_MEM_FN_NAME(cmf0) +template class BOOST_MEM_FN_NAME(cmf0) { public: @@ -92,17 +92,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const) + typedef R (BOOST_MEM_FN_CC T::*F) () const; F f_; template R call(U & u, T const *) const { - BOOST_MEM_FN_RETURN (u.*f_)(); + return (u.*f_)(); } template R call(U & u, void const *) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(); + return (get_pointer(u)->*f_)(); } public: @@ -112,12 +112,12 @@ public: template R operator()(U const & u) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p); + return call(u, p); } R operator()(T const & t) const { - BOOST_MEM_FN_RETURN (t.*f_)(); + return (t.*f_)(); } bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const @@ -133,7 +133,7 @@ public: // mf1 -template class BOOST_MEM_FN_NAME(mf1) +template class BOOST_MEM_FN_NAME(mf1) { public: @@ -143,17 +143,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1)) + typedef R (BOOST_MEM_FN_CC T::*F) (A1); F f_; template R call(U & u, T const *, B1 & b1) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1); + return (u.*f_)(b1); } template R call(U & u, void const *, B1 & b1) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1); + return (get_pointer(u)->*f_)(b1); } public: @@ -162,13 +162,13 @@ public: R operator()(T * p, A1 a1) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1); + return (p->*f_)(a1); } template R operator()(U & u, A1 a1) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1); + return call(u, p, a1); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -176,14 +176,14 @@ public: template R operator()(U const & u, A1 a1) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1); + return call(u, p, a1); } #endif R operator()(T & t, A1 a1) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1); + return (t.*f_)(a1); } bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const @@ -199,7 +199,7 @@ public: // cmf1 -template class BOOST_MEM_FN_NAME(cmf1) +template class BOOST_MEM_FN_NAME(cmf1) { public: @@ -209,17 +209,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const) + typedef R (BOOST_MEM_FN_CC T::*F) (A1) const; F f_; template R call(U & u, T const *, B1 & b1) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1); + return (u.*f_)(b1); } template R call(U & u, void const *, B1 & b1) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1); + return (get_pointer(u)->*f_)(b1); } public: @@ -229,12 +229,12 @@ public: template R operator()(U const & u, A1 a1) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1); + return call(u, p, a1); } R operator()(T const & t, A1 a1) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1); + return (t.*f_)(a1); } bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const @@ -250,7 +250,7 @@ public: // mf2 -template class BOOST_MEM_FN_NAME(mf2) +template class BOOST_MEM_FN_NAME(mf2) { public: @@ -258,17 +258,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2)) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2); F f_; template R call(U & u, T const *, B1 & b1, B2 & b2) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2); + return (u.*f_)(b1, b2); } template R call(U & u, void const *, B1 & b1, B2 & b2) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2); + return (get_pointer(u)->*f_)(b1, b2); } public: @@ -277,13 +277,13 @@ public: R operator()(T * p, A1 a1, A2 a2) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1, a2); + return (p->*f_)(a1, a2); } template R operator()(U & u, A1 a1, A2 a2) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2); + return call(u, p, a1, a2); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -291,14 +291,14 @@ public: template R operator()(U const & u, A1 a1, A2 a2) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2); + return call(u, p, a1, a2); } #endif R operator()(T & t, A1 a1, A2 a2) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2); + return (t.*f_)(a1, a2); } bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const @@ -314,7 +314,7 @@ public: // cmf2 -template class BOOST_MEM_FN_NAME(cmf2) +template class BOOST_MEM_FN_NAME(cmf2) { public: @@ -322,17 +322,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const; F f_; template R call(U & u, T const *, B1 & b1, B2 & b2) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2); + return (u.*f_)(b1, b2); } template R call(U & u, void const *, B1 & b1, B2 & b2) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2); + return (get_pointer(u)->*f_)(b1, b2); } public: @@ -342,12 +342,12 @@ public: template R operator()(U const & u, A1 a1, A2 a2) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2); + return call(u, p, a1, a2); } R operator()(T const & t, A1 a1, A2 a2) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2); + return (t.*f_)(a1, a2); } bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const @@ -363,7 +363,7 @@ public: // mf3 -template class BOOST_MEM_FN_NAME(mf3) +template class BOOST_MEM_FN_NAME(mf3) { public: @@ -371,17 +371,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3)) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3); F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3); + return (u.*f_)(b1, b2, b3); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3); + return (get_pointer(u)->*f_)(b1, b2, b3); } public: @@ -390,13 +390,13 @@ public: R operator()(T * p, A1 a1, A2 a2, A3 a3) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3); + return (p->*f_)(a1, a2, a3); } template R operator()(U & u, A1 a1, A2 a2, A3 a3) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3); + return call(u, p, a1, a2, a3); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -404,14 +404,14 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3); + return call(u, p, a1, a2, a3); } #endif R operator()(T & t, A1 a1, A2 a2, A3 a3) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3); + return (t.*f_)(a1, a2, a3); } bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const @@ -427,7 +427,7 @@ public: // cmf3 -template class BOOST_MEM_FN_NAME(cmf3) +template class BOOST_MEM_FN_NAME(cmf3) { public: @@ -435,17 +435,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const; F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3); + return (u.*f_)(b1, b2, b3); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3); + return (get_pointer(u)->*f_)(b1, b2, b3); } public: @@ -455,12 +455,12 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3); + return call(u, p, a1, a2, a3); } R operator()(T const & t, A1 a1, A2 a2, A3 a3) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3); + return (t.*f_)(a1, a2, a3); } bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const @@ -476,7 +476,7 @@ public: // mf4 -template class BOOST_MEM_FN_NAME(mf4) +template class BOOST_MEM_FN_NAME(mf4) { public: @@ -484,17 +484,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4)) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4); F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4); + return (u.*f_)(b1, b2, b3, b4); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4); + return (get_pointer(u)->*f_)(b1, b2, b3, b4); } public: @@ -503,13 +503,13 @@ public: R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4); + return (p->*f_)(a1, a2, a3, a4); } template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4); + return call(u, p, a1, a2, a3, a4); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -517,14 +517,14 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4); + return call(u, p, a1, a2, a3, a4); } #endif R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4); + return (t.*f_)(a1, a2, a3, a4); } bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const @@ -540,7 +540,7 @@ public: // cmf4 -template class BOOST_MEM_FN_NAME(cmf4) +template class BOOST_MEM_FN_NAME(cmf4) { public: @@ -548,17 +548,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const; F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4); + return (u.*f_)(b1, b2, b3, b4); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4); + return (get_pointer(u)->*f_)(b1, b2, b3, b4); } public: @@ -568,12 +568,12 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4); + return call(u, p, a1, a2, a3, a4); } R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4); + return (t.*f_)(a1, a2, a3, a4); } bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const @@ -589,7 +589,7 @@ public: // mf5 -template class BOOST_MEM_FN_NAME(mf5) +template class BOOST_MEM_FN_NAME(mf5) { public: @@ -597,17 +597,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5)) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5); F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5); + return (u.*f_)(b1, b2, b3, b4, b5); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5); + return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5); } public: @@ -616,13 +616,13 @@ public: R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5); + return (p->*f_)(a1, a2, a3, a4, a5); } template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5); + return call(u, p, a1, a2, a3, a4, a5); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -630,14 +630,14 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5); + return call(u, p, a1, a2, a3, a4, a5); } #endif R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5); + return (t.*f_)(a1, a2, a3, a4, a5); } bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const @@ -653,7 +653,7 @@ public: // cmf5 -template class BOOST_MEM_FN_NAME(cmf5) +template class BOOST_MEM_FN_NAME(cmf5) { public: @@ -661,17 +661,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const; F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5); + return (u.*f_)(b1, b2, b3, b4, b5); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5); + return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5); } public: @@ -681,12 +681,12 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5); + return call(u, p, a1, a2, a3, a4, a5); } R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5); + return (t.*f_)(a1, a2, a3, a4, a5); } bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const @@ -702,7 +702,7 @@ public: // mf6 -template class BOOST_MEM_FN_NAME(mf6) +template class BOOST_MEM_FN_NAME(mf6) { public: @@ -710,17 +710,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6)) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6); F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6); + return (u.*f_)(b1, b2, b3, b4, b5, b6); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6); + return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6); } public: @@ -729,13 +729,13 @@ public: R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6); + return (p->*f_)(a1, a2, a3, a4, a5, a6); } template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6); + return call(u, p, a1, a2, a3, a4, a5, a6); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -743,14 +743,14 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6); + return call(u, p, a1, a2, a3, a4, a5, a6); } #endif R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6); + return (t.*f_)(a1, a2, a3, a4, a5, a6); } bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const @@ -766,7 +766,7 @@ public: // cmf6 -template class BOOST_MEM_FN_NAME(cmf6) +template class BOOST_MEM_FN_NAME(cmf6) { public: @@ -774,17 +774,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const; F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6); + return (u.*f_)(b1, b2, b3, b4, b5, b6); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6); + return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6); } public: @@ -794,12 +794,12 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6); + return call(u, p, a1, a2, a3, a4, a5, a6); } R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6); + return (t.*f_)(a1, a2, a3, a4, a5, a6); } bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const @@ -815,7 +815,7 @@ public: // mf7 -template class BOOST_MEM_FN_NAME(mf7) +template class BOOST_MEM_FN_NAME(mf7) { public: @@ -823,17 +823,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7)) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7); F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7); + return (u.*f_)(b1, b2, b3, b4, b5, b6, b7); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7); + return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7); } public: @@ -842,13 +842,13 @@ public: R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7); + return (p->*f_)(a1, a2, a3, a4, a5, a6, a7); } template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7); + return call(u, p, a1, a2, a3, a4, a5, a6, a7); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -856,14 +856,14 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7); + return call(u, p, a1, a2, a3, a4, a5, a6, a7); } #endif R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7); + return (t.*f_)(a1, a2, a3, a4, a5, a6, a7); } bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const @@ -879,7 +879,7 @@ public: // cmf7 -template class BOOST_MEM_FN_NAME(cmf7) +template class BOOST_MEM_FN_NAME(cmf7) { public: @@ -887,17 +887,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const; F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7); + return (u.*f_)(b1, b2, b3, b4, b5, b6, b7); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7); + return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7); } public: @@ -907,12 +907,12 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7); + return call(u, p, a1, a2, a3, a4, a5, a6, a7); } R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7); + return (t.*f_)(a1, a2, a3, a4, a5, a6, a7); } bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const @@ -928,7 +928,7 @@ public: // mf8 -template class BOOST_MEM_FN_NAME(mf8) +template class BOOST_MEM_FN_NAME(mf8) { public: @@ -936,17 +936,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8)) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8); F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8); + return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8); + return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8); } public: @@ -955,13 +955,13 @@ public: R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8); + return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8); } template R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8); + return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8); } #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS @@ -969,14 +969,14 @@ public: template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8); + return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8); } #endif R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8); + return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8); } bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const @@ -992,7 +992,7 @@ public: // cmf8 -template class BOOST_MEM_FN_NAME(cmf8) +template class BOOST_MEM_FN_NAME(cmf8) { public: @@ -1000,17 +1000,17 @@ public: private: - BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const) + typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const; F f_; template R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const { - BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8); + return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8); } template R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const { - BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8); + return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8); } public: @@ -1019,18 +1019,18 @@ public: R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const { - BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8); + return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8); } template R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const { U const * p = 0; - BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8); + return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8); } R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const { - BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8); + return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8); } bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const