intrusive/detail/has_member_function_callable_with.hpp

0001 //////////////////////////////////////////////////////////////////////////////
0002 //
0003 // (C) Copyright Ion Gaztanaga 2014-2014. Distributed under the Boost
0004 // Software License, Version 1.0. (See accompanying file
0005 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0006 //
0007 // See http://www.boost.org/libs/container for documentation.
0008 //
0009 //////////////////////////////////////////////////////////////////////////////
0010
0011 #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
0012 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
0013
0014 #ifndef BOOST_CONFIG_HPP
0015 #  include <boost/config.hpp>
0016 #endif
0017
0018 //In case no decltype and no variadics, mark that we don't support 0 arg calls due to
0019 //compiler ICE in GCC 3.4/4.0/4.1 and, wrong SFINAE for GCC 4.2/4.3/MSVC10/MSVC11
0020 #if defined(BOOST_NO_CXX11_DECLTYPE) && defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
0021 #  if defined(BOOST_GCC) && (BOOST_GCC < 40400)
0022 #     define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
0023 #  elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200)
0024 #     define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
0025 #  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1800)
0026 #     define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
0027 #  endif
0028 #endif   //#if defined(BOOST_NO_CXX11_DECLTYPE) && defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
0029
0030 #include <cstddef>
0031 #include <boost/move/utility_core.hpp>
0032 #include <boost/move/detail/fwd_macros.hpp>
0033
0034 namespace boost_intrusive_hmfcw {
0035
0036 typedef char yes_type;
0037 struct no_type{ char dummy[2]; };
0038
0039 struct dont_care
0040 {
0041    dont_care(...);
0042 };
0043
0044 #if defined(BOOST_NO_CXX11_DECLTYPE)
0045
0046 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
0047
0048 template<class T>
0049 struct make_dontcare
0050 {
0051    typedef dont_care type;
0052 };
0053
0054 #endif
0055
0056 struct private_type
0057 {
0058    static private_type p;
0059    private_type const &operator,(int) const;
0060 };
0061
0062 template<typename T>
0063 no_type is_private_type(T const &);
0064 yes_type is_private_type(private_type const &);
0065
0066 #endif   //#if defined(BOOST_NO_CXX11_DECLTYPE)
0067
0068 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_DECLTYPE)
0069
0070 template<typename T> struct remove_cv                    {  typedef T type;   };
0071 template<typename T> struct remove_cv<const T>           {  typedef T type;   };
0072 template<typename T> struct remove_cv<const volatile T>  {  typedef T type;   };
0073 template<typename T> struct remove_cv<volatile T>        {  typedef T type;   };
0074
0075 #endif
0076
0077 }  //namespace boost_intrusive_hmfcw {
0078
0079 #endif  //BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
0080
0081 #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
0082    #error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME before including this header!"
0083 #endif
0084
0085 #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
0086    #error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN before including this header!"
0087 #endif
0088
0089 #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX
0090    #error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX before including this header!"
0091 #endif
0092
0093 #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX < BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
0094    #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX value MUST be greater or equal than BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN!"
0095 #endif
0096
0097 #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX == 0
0098    #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF
0099 #else
0100    #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF ,
0101 #endif
0102
0103 #ifndef  BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
0104    #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG not defined!"
0105 #endif
0106
0107 #ifndef  BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
0108    #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END not defined!"
0109 #endif
0110
0111 BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
0112
0113 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE)
0114    //With decltype and variadic templaes, things are pretty easy
0115    template<typename Fun, class ...Args>
0116    struct BOOST_MOVE_CAT(has_member_function_callable_with_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0117    {
0118       template<class U>
0119       static decltype(boost::move_detail::declval<U>().
0120          BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...)
0121             , boost_intrusive_hmfcw::yes_type()) Test(U* f);
0122       template<class U>
0123       static boost_intrusive_hmfcw::no_type Test(...);
0124       static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
0125    };
0126
0127 #else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_DECLTYPE)
0128
0129    /////////////////////////////////////////////////////////
0130    /////////////////////////////////////////////////////////
0131    //
0132    //    has_member_function_callable_with_impl_XXX
0133    //    declaration, special case and 0 arg specializaton
0134    //
0135    /////////////////////////////////////////////////////////
0136
0137    template <typename Type>
0138    class BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0139    {
0140       struct BaseMixin
0141       {
0142          void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
0143          {} //Some compilers require the definition or linker errors happen
0144       };
0145
0146       struct Base
0147          : public boost_intrusive_hmfcw::remove_cv<Type>::type, public BaseMixin
0148       {  //Declare the unneeded default constructor as some old compilers wrongly require it with is_convertible
0149          Base(){}
0150       };
0151       template <typename T, T t> class Helper{};
0152
0153       template <typename U>
0154       static boost_intrusive_hmfcw::no_type  deduce
0155          (U*, Helper<void (BaseMixin::*)(), &U::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME>* = 0);
0156       static boost_intrusive_hmfcw::yes_type deduce(...);
0157
0158       public:
0159       static const bool value = sizeof(boost_intrusive_hmfcw::yes_type) == sizeof(deduce((Base*)0));
0160    };
0161
0162    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
0163       /////////////////////////////////////////////////////////
0164       /////////////////////////////////////////////////////////
0165       //
0166       //    has_member_function_callable_with_impl_XXX for 1 to N arguments
0167       //
0168       /////////////////////////////////////////////////////////
0169       /////////////////////////////////////////////////////////
0170
0171       //defined(BOOST_NO_CXX11_DECLTYPE) must be true
0172       template<class Fun>
0173       struct FunWrapTmpl : Fun
0174       {
0175          using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
0176          FunWrapTmpl();
0177          template<class ...DontCares>
0178          boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(DontCares...) const;
0179       };
0180
0181       template<typename Fun, bool HasFunc, class ...Args>
0182       struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME);
0183
0184       //No BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME member specialization
0185       template<typename Fun, class ...Args>
0186       struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0187          <Fun, false, Args...>
0188       {
0189          static const bool value = false;
0190       };
0191
0192       template<typename Fun, class ...Args>
0193       struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true, Args...>
0194       {
0195          static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) == sizeof(boost_intrusive_hmfcw::is_private_type
0196                                              ( (::boost::move_detail::declval
0197                                                    < FunWrapTmpl<Fun> >().
0198                                                    BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...), 0) )
0199                                           )
0200                                     );
0201       };
0202
0203       template<typename Fun, class ...Args>
0204       struct BOOST_MOVE_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0205          : public BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0206             <Fun
0207             , BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value
0208             , Args...>
0209       {};
0210    #else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
0211
0212       /////////////////////////////////////////////////////////
0213       /////////////////////////////////////////////////////////
0214       //
0215       //    has_member_function_callable_with_impl_XXX specializations
0216       //
0217       /////////////////////////////////////////////////////////
0218
0219       template<typename Fun, bool HasFunc BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASSDFLT,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
0220       struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME);
0221
0222       //No BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME member specialization
0223       template<typename Fun BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASS,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
0224       struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0225          <Fun, false BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_TARG,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
0226       {
0227          static const bool value = false;
0228       };
0229
0230       #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
0231          //0 arg specialization when BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME is present
0232          #if !defined(BOOST_NO_CXX11_DECLTYPE)
0233
0234             template<typename Fun>
0235             struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
0236             {
0237                template<class U>
0238                static decltype(boost::move_detail::declval<U>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
0239                   , boost_intrusive_hmfcw::yes_type()) Test(U* f);
0240
0241                template<class U>
0242                static boost_intrusive_hmfcw::no_type Test(...);
0243                static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
0244             };
0245
0246          #else //defined(BOOST_NO_CXX11_DECLTYPE)
0247
0248             #if !defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
0249
0250                template<class F, std::size_t N = sizeof(boost::move_detail::declval<F>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(), 0)>
0251                struct BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0252                {  boost_intrusive_hmfcw::yes_type dummy[N ? 1 : 2];   };
0253
0254                template<typename Fun>
0255                struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
0256                {
0257                   template<class U> static BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>
0258                      Test(BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*);
0259                   template<class U> static boost_intrusive_hmfcw::no_type Test(...);
0260                   static const bool value = sizeof(Test< Fun >(0)) == sizeof(boost_intrusive_hmfcw::yes_type);
0261                };
0262
0263             #else //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
0264
0265                template<typename Fun>
0266                struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
0267                {  //Some compilers gives ICE when instantiating the 0 arg version so it is not supported.
0268                   static const bool value = true;
0269                };
0270
0271             #endif//!defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
0272          #endif   //!defined(BOOST_NO_CXX11_DECLTYPE)
0273       #endif   //#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
0274
0275       #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX > 0
0276          //1 to N arg specialization when BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME is present
0277          //Declare some unneeded default constructor as some old compilers wrongly require it with is_convertible
0278          #if defined(BOOST_NO_CXX11_DECLTYPE)
0279             #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION(N)\
0280             \
0281             template<class Fun>\
0282             struct BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)\
0283                : Fun\
0284             {\
0285                using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;\
0286                BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)();\
0287                boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME\
0288                   (BOOST_MOVE_REPEAT##N(boost_intrusive_hmfcw::dont_care)) const;\
0289             };\
0290             \
0291             template<typename Fun, BOOST_MOVE_CLASS##N>\
0292             struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true, BOOST_MOVE_TARG##N>\
0293             {\
0294                static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) == sizeof(boost_intrusive_hmfcw::is_private_type\
0295                                                    ( (::boost::move_detail::declval\
0296                                                          < BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun> >().\
0297                                                       BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(BOOST_MOVE_DECLVAL##N), 0) )\
0298                                                 )\
0299                                           );\
0300             };\
0301             //
0302          #else
0303             #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION(N)\
0304             template<typename Fun, BOOST_MOVE_CLASS##N>\
0305             struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)\
0306                <Fun, true, BOOST_MOVE_TARG##N>\
0307             {\
0308                template<class U>\
0309                static decltype(boost::move_detail::declval<U>().\
0310                   BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(BOOST_MOVE_DECLVAL##N)\
0311                      , boost_intrusive_hmfcw::yes_type()) Test(U* f);\
0312                template<class U>\
0313                static boost_intrusive_hmfcw::no_type Test(...);\
0314                static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);\
0315             };\
0316             //
0317          #endif
0318          ////////////////////////////////////
0319          // Build and invoke BOOST_MOVE_ITERATE_NTOM macrofunction, note that N has to be at least 1
0320          ////////////////////////////////////
0321          #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
0322             #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN 1
0323          #else
0324             #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
0325          #endif
0326          BOOST_MOVE_CAT
0327             (BOOST_MOVE_CAT(BOOST_MOVE_CAT(BOOST_MOVE_ITERATE_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN), TO)
0328             ,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)
0329                (BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION)
0330          #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION
0331          #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN
0332          ////////////////////////////////////
0333          // End of BOOST_MOVE_ITERATE_NTOM
0334          ////////////////////////////////////
0335       #endif   //BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX > 0
0336
0337       /////////////////////////////////////////////////////////
0338       /////////////////////////////////////////////////////////
0339       //
0340       //       has_member_function_callable_with_FUNC
0341       //
0342       /////////////////////////////////////////////////////////
0343       /////////////////////////////////////////////////////////
0344
0345       //Otherwise use the preprocessor
0346       template<typename Fun BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASSDFLT,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
0347       struct BOOST_MOVE_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0348          : public BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
0349             <Fun
0350             , BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value
0351             BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_TARG,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
0352       {};
0353    #endif   //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
0354 #endif
0355
0356 BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
0357
0358 //Undef local macros
0359 #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF
0360
0361 //Undef user defined macros
0362 #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
0363 #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
0364 #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX
0365 #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
0366 #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END