third_party/boost/include/boost/mpl/has_xxx.hpp - webm/webmlive - Git at Google


 #ifndef BOOST_MPL_HAS_XXX_HPP_INCLUDED
 #define BOOST_MPL_HAS_XXX_HPP_INCLUDED

 // Copyright Aleksey Gurtovoy 2002-2006
 // Copyright David Abrahams 2002-2003
 // Copyright Daniel Walker 2007
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org/libs/mpl for documentation.

 // $Id: has_xxx.hpp 64146 2010-07-19 00:46:31Z djwalker $
 // $Date: 2010-07-18 20:46:31 -0400 (Sun, 18 Jul 2010) $
 // $Revision: 64146 $

 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/aux_/na_spec.hpp>
 #include <boost/mpl/aux_/type_wrapper.hpp>
 #include <boost/mpl/aux_/yes_no.hpp>
 #include <boost/mpl/aux_/config/gcc.hpp>
 #include <boost/mpl/aux_/config/has_xxx.hpp>
 #include <boost/mpl/aux_/config/msvc_typename.hpp>
 #include <boost/mpl/aux_/config/msvc.hpp>
 #include <boost/mpl/aux_/config/static_constant.hpp>
 #include <boost/mpl/aux_/config/workaround.hpp>

 #include <boost/preprocessor/array/elem.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/control/if.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>

 #if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) )
 # include <boost/type_traits/is_class.hpp>
 #endif

 #if !defined(BOOST_MPL_CFG_NO_HAS_XXX)

 #   if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

 // agurt, 11/sep/02: MSVC-specific version (< 7.1), based on a USENET
 // newsgroup's posting by John Madsen (comp.lang.c++.moderated,
 // 1999-11-12 19:17:06 GMT); the code is _not_ standard-conforming, but
 // it works way more reliably than the SFINAE-based implementation

 // Modified dwa 8/Oct/02 to handle reference types.

 #   include <boost/mpl/if.hpp>
 #   include <boost/mpl/bool.hpp>

 namespace boost { namespace mpl { namespace aux {

 struct has_xxx_tag;

 #if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
 template< typename U > struct msvc_incomplete_array
 {
     typedef char (&type)[sizeof(U) + 1];
 };
 #endif

 template< typename T >
 struct msvc_is_incomplete
 {
     // MSVC is capable of some kinds of SFINAE.  If U is an incomplete
     // type, it won't pick the second overload
     static char tester(...);

 #if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
     template< typename U >
     static typename msvc_incomplete_array<U>::type tester(type_wrapper<U>);
 #else
     template< typename U >
     static char (& tester(type_wrapper<U>) )[sizeof(U)+1];
 #endif

     BOOST_STATIC_CONSTANT(bool, value =
           sizeof(tester(type_wrapper<T>())) == 1
         );
 };

 template<>
 struct msvc_is_incomplete<int>
 {
     BOOST_STATIC_CONSTANT(bool, value = false);
 };

 }}}

 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, default_) \
 template< typename T, typename name = ::boost::mpl::aux::has_xxx_tag > \
 struct BOOST_PP_CAT(trait,_impl) : T \
 { \
     static boost::mpl::aux::no_tag \
     test(void(*)(::boost::mpl::aux::has_xxx_tag)); \
     \
     static boost::mpl::aux::yes_tag test(...); \
     \
     BOOST_STATIC_CONSTANT(bool, value = \
           sizeof(test(static_cast<void(*)(name)>(0))) \
             != sizeof(boost::mpl::aux::no_tag) \
         ); \
     typedef boost::mpl::bool_<value> type; \
 }; \
 \
 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
 struct trait \
     : boost::mpl::if_c< \
           boost::mpl::aux::msvc_is_incomplete<T>::value \
         , boost::mpl::bool_<false> \
         , BOOST_PP_CAT(trait,_impl)<T> \
         >::type \
 { \
 }; \
 \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, void) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, bool) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, char) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed char) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned char) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed short) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned short) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed int) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned int) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed long) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned long) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, float) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, double) \
 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, long double) \
 /**/

 #   define BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, T) \
 template<> struct trait<T> \
 { \
     BOOST_STATIC_CONSTANT(bool, value = false); \
     typedef boost::mpl::bool_<false> type; \
 }; \
 /**/

 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \
     BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \
     BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, wchar_t) \
 /**/
 #else
 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \
     BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \
 /**/
 #endif


 // SFINAE-based implementations below are derived from a USENET newsgroup's
 // posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST)

 #   elif BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
       || BOOST_WORKAROUND(__IBMCPP__, <= 700)

 // MSVC 7.1+ & VACPP

 // agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE
 // applied to partial specialization to fix some apparently random failures
 // (thanks to Daniel Wallin for researching this!)

 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
 template< typename T > \
 struct BOOST_PP_CAT(trait, _msvc_sfinae_helper) \
 { \
     typedef void type; \
 };\
 \
 template< typename T, typename U = void > \
 struct BOOST_PP_CAT(trait,_impl_) \
 { \
     BOOST_STATIC_CONSTANT(bool, value = false); \
     typedef boost::mpl::bool_<value> type; \
 }; \
 \
 template< typename T > \
 struct BOOST_PP_CAT(trait,_impl_)< \
       T \
     , typename BOOST_PP_CAT(trait, _msvc_sfinae_helper)< typename T::name >::type \
     > \
 { \
     BOOST_STATIC_CONSTANT(bool, value = true); \
     typedef boost::mpl::bool_<value> type; \
 }; \
 \
 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
 struct trait \
     : BOOST_PP_CAT(trait,_impl_)<T> \
 { \
 }; \
 /**/

 #   elif BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) )

 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF(trait, trait_tester, name, default_) \
 template< typename T, bool IS_CLASS > \
 struct trait_tester \
 { \
     BOOST_STATIC_CONSTANT( bool,  value = false ); \
 }; \
 template< typename T > \
 struct trait_tester< T, true > \
 { \
     struct trait_tester_impl \
     { \
         template < class U > \
         static int  resolve( boost::mpl::aux::type_wrapper<U> const volatile * \
                            , boost::mpl::aux::type_wrapper<typename U::name >* = 0 ); \
         static char resolve( ... ); \
     }; \
     typedef boost::mpl::aux::type_wrapper<T> t_; \
     BOOST_STATIC_CONSTANT( bool, value = ( sizeof( trait_tester_impl::resolve( static_cast< t_ * >(0) ) ) == sizeof(int) ) ); \
 }; \
 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
 struct trait           \
 {                      \
     BOOST_STATIC_CONSTANT( bool, value = (trait_tester< T, boost::is_class< T >::value >::value) );     \
     typedef boost::mpl::bool_< trait< T, fallback_ >::value > type; \
 };

 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
     BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF( trait \
                                          , BOOST_PP_CAT(trait,_tester)      \
                                          , name       \
                                          , default_ ) \
 /**/

 #   else // other SFINAE-capable compilers

 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
 struct trait \
 { \
     struct gcc_3_2_wknd \
     { \
         template< typename U > \
         static boost::mpl::aux::yes_tag test( \
               boost::mpl::aux::type_wrapper<U> const volatile* \
             , boost::mpl::aux::type_wrapper<BOOST_MSVC_TYPENAME U::name>* = 0 \
             ); \
     \
         static boost::mpl::aux::no_tag test(...); \
     }; \
     \
     typedef boost::mpl::aux::type_wrapper<T> t_; \
     BOOST_STATIC_CONSTANT(bool, value = \
           sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) \
             == sizeof(boost::mpl::aux::yes_tag) \
         ); \
     typedef boost::mpl::bool_<value> type; \
 }; \
 /**/

 #   endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300)


 #else // BOOST_MPL_CFG_NO_HAS_XXX

 // placeholder implementation

 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
 struct trait \
 { \
     BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \
     typedef fallback_ type; \
 }; \
 /**/

 #endif

 #define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \
     BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false) \
 /**/


 #if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)

 // Create a boolean Metafunction to detect a nested template
 // member. This implementation is based on a USENET newsgroup's
 // posting by Aleksey Gurtovoy (comp.lang.c++.moderated, 2002-03-19),
 // Rani Sharoni's USENET posting cited above, the non-template has_xxx
 // implementations above, and discussion on the Boost mailing list.

 #   if !defined(BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES)
 #     if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
 #       define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 1
 #     endif
 #   endif

 #   if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION)
 #     if (defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS))
 #       define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 1
 #     endif
 #   endif

 #   if !defined(BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE)
 #     if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
 #       define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 1
 #     endif
 #   endif

 // NOTE: Many internal implementation macros take a Boost.Preprocessor
 // array argument called args which is of the following form.
 //           ( 4, ( trait, name, max_arity, default_ ) )

 #   define BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \
       BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _introspect) \
     /**/

 #   define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \
       BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _substitute), n) \
     /**/

 #   define BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) \
       BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _test) \
     /**/

 // Thanks to Guillaume Melquiond for pointing out the need for the
 // "substitute" template as an argument to the overloaded test
 // functions to get SFINAE to work for member templates with the
 // correct name but different number of arguments.
 #   define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE(z, n, args) \
       template< \
           template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename V) > class V \
        > \
       struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) { \
       }; \
     /**/

 #   define BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \
       BOOST_PP_REPEAT( \
           BOOST_PP_ARRAY_ELEM(2, args) \
         , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE \
         , args \
       ) \
     /**/

 #   if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION
 #     define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \
         template< typename V > \
         static boost::mpl::aux::no_tag \
         BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \
       /**/
 #   else
 #     define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \
         static boost::mpl::aux::no_tag \
         BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \
       /**/
 #   endif

 #   if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES
 #     define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT(z, n, args) \
         template< typename V > \
         static boost::mpl::aux::yes_tag \
         BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \
             boost::mpl::aux::type_wrapper< V > const volatile* \
           , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) < \
                 V::template BOOST_PP_ARRAY_ELEM(1, args) \
             >* = 0 \
         ); \
       /**/
 #     define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \
         BOOST_PP_REPEAT( \
             BOOST_PP_ARRAY_ELEM(2, args) \
           , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT \
           , args \
         ) \
       /**/
 #   else
 #     define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \
         template< typename V > \
         static boost::mpl::aux::yes_tag \
         BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \
             V const volatile* \
           , member_macro(args, V, T)* = 0 \
         ); \
       /**/
 #   endif

 #   if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION
 #     define BOOST_MPL_HAS_MEMBER_TEST(args) \
           sizeof(BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U >(0)) \
               == sizeof(boost::mpl::aux::yes_tag) \
       /**/
 #   else
 #     if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES
 #       define BOOST_MPL_HAS_MEMBER_TEST(args) \
           sizeof( \
               BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \
                   static_cast< boost::mpl::aux::type_wrapper< U >* >(0) \
               ) \
           ) == sizeof(boost::mpl::aux::yes_tag) \
         /**/
 #     else
 #       define BOOST_MPL_HAS_MEMBER_TEST(args) \
           sizeof( \
               BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \
                   static_cast< U* >(0) \
               ) \
           ) == sizeof(boost::mpl::aux::yes_tag) \
         /**/
 #     endif
 #   endif

 #   define BOOST_MPL_HAS_MEMBER_INTROSPECT( \
                args, substitute_macro, member_macro \
            ) \
       template< typename U > \
       struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) { \
           BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \
           BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \
           BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \
           BOOST_STATIC_CONSTANT( \
               bool, value = BOOST_MPL_HAS_MEMBER_TEST(args) \
           ); \
           typedef boost::mpl::bool_< value > type; \
       }; \
     /**/

 #   define BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \
                args, introspect_macro, substitute_macro, member_macro \
            ) \
       template< \
           typename T \
         , typename fallback_ \
               = boost::mpl::bool_< BOOST_PP_ARRAY_ELEM(3, args) > \
       > \
       class BOOST_PP_ARRAY_ELEM(0, args) { \
           introspect_macro(args, substitute_macro, member_macro) \
       public: \
           static const bool value \
               = BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::value; \
           typedef typename BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< \
               T \
           >::type type; \
       }; \
     /**/

 // BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE expands to the full
 // implementation of the function-based metafunction. Compile with -E
 // to see the preprocessor output for this macro.
 #   define BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \
                args, substitute_macro, member_macro \
            ) \
       BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \
           args \
         , BOOST_MPL_HAS_MEMBER_INTROSPECT \
         , substitute_macro \
         , member_macro \
       ) \
     /**/

 #   if BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE

 #     if !defined(BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE)
 #       if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
 #         define BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE 1
 #       endif
 #     endif

 #     if !BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE
 #       define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
                    args, n \
                ) \
           BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \
         /**/
 #     else
 #       define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
                    args, n \
                ) \
           BOOST_PP_CAT( \
               boost_mpl_has_xxx_ \
             , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \
           ) \
         /**/
 #     endif

 #     define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME( \
                  args \
              ) \
         BOOST_PP_CAT( \
             BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
                 args, 0 \
             ) \
           , _tag \
         ) \
       /**/

 #     define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \
                  z, n, args \
              ) \
         template< \
              template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename U) > class U \
         > \
         struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
                 args, n \
                ) { \
             typedef \
                 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \
                 type; \
         }; \
       /**/

 #     define BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \
                  args, substitute_macro \
              ) \
         typedef void \
             BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args); \
         BOOST_PP_REPEAT( \
             BOOST_PP_ARRAY_ELEM(2, args) \
           , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE \
           , args \
         ) \
       /**/

 #     define BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE( \
                  args, member_macro \
              ) \
         template< \
             typename U \
           , typename V \
                 = BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \
         > \
         struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) { \
             BOOST_STATIC_CONSTANT(bool, value = false); \
             typedef boost::mpl::bool_< value > type; \
         }; \
       /**/

 #     define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE( \
                  z, n, args \
              ) \
         template< typename U > \
         struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< \
             U \
           , typename \
                 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
                     args, n \
                 )< \
                     BOOST_MSVC_TYPENAME U::BOOST_PP_ARRAY_ELEM(1, args)< > \
                 >::type \
         > { \
             BOOST_STATIC_CONSTANT(bool, value = true); \
             typedef boost::mpl::bool_< value > type; \
         }; \
       /**/

 #     define BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE( \
                  args, member_macro \
              ) \
         BOOST_PP_REPEAT( \
             BOOST_PP_ARRAY_ELEM(2, args) \
           , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE \
           , args \
         ) \
       /**/

 #     define BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE( \
                  args, substitute_macro, member_macro \
              ) \
         BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE(args, member_macro) \
         BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE(args, member_macro) \
         template< typename U > \
         struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \
             : BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U > { \
         }; \
       /**/

 // BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE expands to the full
 // implementation of the template-based metafunction. Compile with -E
 // to see the preprocessor output for this macro.
 //
 // Note that if BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE is
 // defined BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE needs
 // to be expanded at namespace level before
 // BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE can be used.
 #     define BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \
                  args, substitute_macro, member_macro \
              ) \
         BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \
             args, substitute_macro \
         ) \
         BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \
             args \
           , BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE \
           , substitute_macro \
           , member_macro \
         ) \
       /**/

 #   endif // BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE

 // Note: In the current implementation the parameter and access macros
 // are no longer expanded.
 #   if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
 #     define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \
         BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \
             ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \
           , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \
           , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \
         ) \
       /**/
 #   else
 #     define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \
         BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \
             ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \
           , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \
           , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \
         ) \
       /**/
 #   endif

 #else // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE

 // placeholder implementation

 #   define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \
       template< typename T \
               , typename fallback_ = boost::mpl::bool_< default_ > > \
       struct trait { \
           BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \
           typedef fallback_ type; \
       }; \
     /**/

 #endif // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE

 #   define BOOST_MPL_HAS_XXX_TEMPLATE_DEF(name) \
       BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF( \
           BOOST_PP_CAT(has_, name), name, false \
       ) \
     /**/

 #endif // BOOST_MPL_HAS_XXX_HPP_INCLUDED

	#ifndef BOOST_MPL_HAS_XXX_HPP_INCLUDED
	#define BOOST_MPL_HAS_XXX_HPP_INCLUDED

	// Copyright Aleksey Gurtovoy 2002-2006
	// Copyright David Abrahams 2002-2003
	// Copyright Daniel Walker 2007
	//
	// Distributed under the Boost Software License, Version 1.0.
	// (See accompanying file LICENSE_1_0.txt or copy at
	// http://www.boost.org/LICENSE_1_0.txt)
	//
	// See http://www.boost.org/libs/mpl for documentation.

	// $Id: has_xxx.hpp 64146 2010-07-19 00:46:31Z djwalker $
	// $Date: 2010-07-18 20:46:31 -0400 (Sun, 18 Jul 2010) $
	// $Revision: 64146 $

	#include <boost/mpl/bool.hpp>
	#include <boost/mpl/aux_/na_spec.hpp>
	#include <boost/mpl/aux_/type_wrapper.hpp>
	#include <boost/mpl/aux_/yes_no.hpp>
	#include <boost/mpl/aux_/config/gcc.hpp>
	#include <boost/mpl/aux_/config/has_xxx.hpp>
	#include <boost/mpl/aux_/config/msvc_typename.hpp>
	#include <boost/mpl/aux_/config/msvc.hpp>
	#include <boost/mpl/aux_/config/static_constant.hpp>
	#include <boost/mpl/aux_/config/workaround.hpp>

	#include <boost/preprocessor/array/elem.hpp>
	#include <boost/preprocessor/cat.hpp>
	#include <boost/preprocessor/control/if.hpp>
	#include <boost/preprocessor/repetition/enum_params.hpp>
	#include <boost/preprocessor/repetition/enum_trailing_params.hpp>

	#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) )
	# include <boost/type_traits/is_class.hpp>
	#endif

	#if !defined(BOOST_MPL_CFG_NO_HAS_XXX)

	# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

	// agurt, 11/sep/02: MSVC-specific version (< 7.1), based on a USENET
	// newsgroup's posting by John Madsen (comp.lang.c++.moderated,
	// 1999-11-12 19:17:06 GMT); the code is _not_ standard-conforming, but
	// it works way more reliably than the SFINAE-based implementation

	// Modified dwa 8/Oct/02 to handle reference types.

	# include <boost/mpl/if.hpp>
	# include <boost/mpl/bool.hpp>

	namespace boost { namespace mpl { namespace aux {

	struct has_xxx_tag;

	#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
	template< typename U > struct msvc_incomplete_array
	{
	typedef char (&type)[sizeof(U) + 1];
	};
	#endif

	template< typename T >
	struct msvc_is_incomplete
	{
	// MSVC is capable of some kinds of SFINAE. If U is an incomplete
	// type, it won't pick the second overload
	static char tester(...);

	#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
	template< typename U >
	static typename msvc_incomplete_array<U>::type tester(type_wrapper<U>);
	#else
	template< typename U >
	static char (& tester(type_wrapper<U>) )[sizeof(U)+1];
	#endif

	BOOST_STATIC_CONSTANT(bool, value =
	sizeof(tester(type_wrapper<T>())) == 1
	);
	};

	template<>
	struct msvc_is_incomplete<int>
	{
	BOOST_STATIC_CONSTANT(bool, value = false);
	};

	}}}

	# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, default_) \
	template< typename T, typename name = ::boost::mpl::aux::has_xxx_tag > \
	struct BOOST_PP_CAT(trait,_impl) : T \
	{ \
	static boost::mpl::aux::no_tag \
	test(void(*)(::boost::mpl::aux::has_xxx_tag)); \
	\
	static boost::mpl::aux::yes_tag test(...); \
	\
	BOOST_STATIC_CONSTANT(bool, value = \
	sizeof(test(static_cast<void(*)(name)>(0))) \
	!= sizeof(boost::mpl::aux::no_tag) \
	); \
	typedef boost::mpl::bool_<value> type; \
	}; \
	\
	template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
	struct trait \
	: boost::mpl::if_c< \
	boost::mpl::aux::msvc_is_incomplete<T>::value \
	, boost::mpl::bool_<false> \
	, BOOST_PP_CAT(trait,_impl)<T> \
	>::type \
	{ \
	}; \
	\
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, void) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, bool) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, char) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed char) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned char) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed short) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned short) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed int) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned int) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed long) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned long) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, float) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, double) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, long double) \
	/**/

	# define BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, T) \
	template<> struct trait<T> \
	{ \
	BOOST_STATIC_CONSTANT(bool, value = false); \
	typedef boost::mpl::bool_<false> type; \
	}; \
	/**/

	#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
	# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \
	BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \
	BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, wchar_t) \
	/**/
	#else
	# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \
	BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \
	/**/
	#endif


	// SFINAE-based implementations below are derived from a USENET newsgroup's
	// posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST)

	# elif BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
	\|\| BOOST_WORKAROUND(__IBMCPP__, <= 700)

	// MSVC 7.1+ & VACPP

	// agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE
	// applied to partial specialization to fix some apparently random failures
	// (thanks to Daniel Wallin for researching this!)

	# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
	template< typename T > \
	struct BOOST_PP_CAT(trait, _msvc_sfinae_helper) \
	{ \
	typedef void type; \
	};\
	\
	template< typename T, typename U = void > \
	struct BOOST_PP_CAT(trait,_impl_) \
	{ \
	BOOST_STATIC_CONSTANT(bool, value = false); \
	typedef boost::mpl::bool_<value> type; \
	}; \
	\
	template< typename T > \
	struct BOOST_PP_CAT(trait,_impl_)< \
	T \
	, typename BOOST_PP_CAT(trait, _msvc_sfinae_helper)< typename T::name >::type \
	> \
	{ \
	BOOST_STATIC_CONSTANT(bool, value = true); \
	typedef boost::mpl::bool_<value> type; \
	}; \
	\
	template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
	struct trait \
	: BOOST_PP_CAT(trait,_impl_)<T> \
	{ \
	}; \
	/**/

	# elif BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) )

	# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF(trait, trait_tester, name, default_) \
	template< typename T, bool IS_CLASS > \
	struct trait_tester \
	{ \
	BOOST_STATIC_CONSTANT( bool, value = false ); \
	}; \
	template< typename T > \
	struct trait_tester< T, true > \
	{ \
	struct trait_tester_impl \
	{ \
	template < class U > \
	static int resolve( boost::mpl::aux::type_wrapper<U> const volatile * \
	, boost::mpl::aux::type_wrapper<typename U::name >* = 0 ); \
	static char resolve( ... ); \
	}; \
	typedef boost::mpl::aux::type_wrapper<T> t_; \
	BOOST_STATIC_CONSTANT( bool, value = ( sizeof( trait_tester_impl::resolve( static_cast< t_ * >(0) ) ) == sizeof(int) ) ); \
	}; \
	template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
	struct trait \
	{ \
	BOOST_STATIC_CONSTANT( bool, value = (trait_tester< T, boost::is_class< T >::value >::value) ); \
	typedef boost::mpl::bool_< trait< T, fallback_ >::value > type; \
	};

	# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
	BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF( trait \
	, BOOST_PP_CAT(trait,_tester) \
	, name \
	, default_ ) \
	/**/

	# else // other SFINAE-capable compilers

	# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
	template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
	struct trait \
	{ \
	struct gcc_3_2_wknd \
	{ \
	template< typename U > \
	static boost::mpl::aux::yes_tag test( \
	boost::mpl::aux::type_wrapper<U> const volatile* \
	, boost::mpl::aux::type_wrapper<BOOST_MSVC_TYPENAME U::name>* = 0 \
	); \
	\
	static boost::mpl::aux::no_tag test(...); \
	}; \
	\
	typedef boost::mpl::aux::type_wrapper<T> t_; \
	BOOST_STATIC_CONSTANT(bool, value = \
	sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) \
	== sizeof(boost::mpl::aux::yes_tag) \
	); \
	typedef boost::mpl::bool_<value> type; \
	}; \
	/**/

	# endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300)


	#else // BOOST_MPL_CFG_NO_HAS_XXX

	// placeholder implementation

	# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \
	template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \
	struct trait \
	{ \
	BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \
	typedef fallback_ type; \
	}; \
	/**/

	#endif

	#define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \
	BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false) \
	/**/


	#if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)

	// Create a boolean Metafunction to detect a nested template
	// member. This implementation is based on a USENET newsgroup's
	// posting by Aleksey Gurtovoy (comp.lang.c++.moderated, 2002-03-19),
	// Rani Sharoni's USENET posting cited above, the non-template has_xxx
	// implementations above, and discussion on the Boost mailing list.

	# if !defined(BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES)
	# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
	# define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 1
	# endif
	# endif

	# if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION)
	# if (defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS))
	# define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 1
	# endif
	# endif

	# if !defined(BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE)
	# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
	# define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 1
	# endif
	# endif

	// NOTE: Many internal implementation macros take a Boost.Preprocessor
	// array argument called args which is of the following form.
	// ( 4, ( trait, name, max_arity, default_ ) )

	# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \
	BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _introspect) \
	/**/

	# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \
	BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _substitute), n) \
	/**/

	# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) \
	BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _test) \
	/**/

	// Thanks to Guillaume Melquiond for pointing out the need for the
	// "substitute" template as an argument to the overloaded test
	// functions to get SFINAE to work for member templates with the
	// correct name but different number of arguments.
	# define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE(z, n, args) \
	template< \
	template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename V) > class V \
	> \
	struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) { \
	}; \
	/**/

	# define BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \
	BOOST_PP_REPEAT( \
	BOOST_PP_ARRAY_ELEM(2, args) \
	, BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE \
	, args \
	) \
	/**/

	# if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION
	# define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \
	template< typename V > \
	static boost::mpl::aux::no_tag \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \
	/**/
	# else
	# define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \
	static boost::mpl::aux::no_tag \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \
	/**/
	# endif

	# if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES
	# define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT(z, n, args) \
	template< typename V > \
	static boost::mpl::aux::yes_tag \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \
	boost::mpl::aux::type_wrapper< V > const volatile* \
	, BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) < \
	V::template BOOST_PP_ARRAY_ELEM(1, args) \
	>* = 0 \
	); \
	/**/
	# define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \
	BOOST_PP_REPEAT( \
	BOOST_PP_ARRAY_ELEM(2, args) \
	, BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT \
	, args \
	) \
	/**/
	# else
	# define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \
	template< typename V > \
	static boost::mpl::aux::yes_tag \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \
	V const volatile* \
	, member_macro(args, V, T)* = 0 \
	); \
	/**/
	# endif

	# if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION
	# define BOOST_MPL_HAS_MEMBER_TEST(args) \
	sizeof(BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U >(0)) \
	== sizeof(boost::mpl::aux::yes_tag) \
	/**/
	# else
	# if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES
	# define BOOST_MPL_HAS_MEMBER_TEST(args) \
	sizeof( \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \
	static_cast< boost::mpl::aux::type_wrapper< U >* >(0) \
	) \
	) == sizeof(boost::mpl::aux::yes_tag) \
	/**/
	# else
	# define BOOST_MPL_HAS_MEMBER_TEST(args) \
	sizeof( \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \
	static_cast< U* >(0) \
	) \
	) == sizeof(boost::mpl::aux::yes_tag) \
	/**/
	# endif
	# endif

	# define BOOST_MPL_HAS_MEMBER_INTROSPECT( \
	args, substitute_macro, member_macro \
	) \
	template< typename U > \
	struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) { \
	BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \
	BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \
	BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \
	BOOST_STATIC_CONSTANT( \
	bool, value = BOOST_MPL_HAS_MEMBER_TEST(args) \
	); \
	typedef boost::mpl::bool_< value > type; \
	}; \
	/**/

	# define BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \
	args, introspect_macro, substitute_macro, member_macro \
	) \
	template< \
	typename T \
	, typename fallback_ \
	= boost::mpl::bool_< BOOST_PP_ARRAY_ELEM(3, args) > \
	> \
	class BOOST_PP_ARRAY_ELEM(0, args) { \
	introspect_macro(args, substitute_macro, member_macro) \
	public: \
	static const bool value \
	= BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::value; \
	typedef typename BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< \
	T \
	>::type type; \
	}; \
	/**/

	// BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE expands to the full
	// implementation of the function-based metafunction. Compile with -E
	// to see the preprocessor output for this macro.
	# define BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \
	args, substitute_macro, member_macro \
	) \
	BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \
	args \
	, BOOST_MPL_HAS_MEMBER_INTROSPECT \
	, substitute_macro \
	, member_macro \
	) \
	/**/

	# if BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE

	# if !defined(BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE)
	# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
	# define BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE 1
	# endif
	# endif

	# if !BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE
	# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
	args, n \
	) \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \
	/**/
	# else
	# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
	args, n \
	) \
	BOOST_PP_CAT( \
	boost_mpl_has_xxx_ \
	, BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \
	) \
	/**/
	# endif

	# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME( \
	args \
	) \
	BOOST_PP_CAT( \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
	args, 0 \
	) \
	, _tag \
	) \
	/**/

	# define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \
	z, n, args \
	) \
	template< \
	template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename U) > class U \
	> \
	struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
	args, n \
	) { \
	typedef \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \
	type; \
	}; \
	/**/

	# define BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \
	args, substitute_macro \
	) \
	typedef void \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args); \
	BOOST_PP_REPEAT( \
	BOOST_PP_ARRAY_ELEM(2, args) \
	, BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE \
	, args \
	) \
	/**/

	# define BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE( \
	args, member_macro \
	) \
	template< \
	typename U \
	, typename V \
	= BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \
	> \
	struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) { \
	BOOST_STATIC_CONSTANT(bool, value = false); \
	typedef boost::mpl::bool_< value > type; \
	}; \
	/**/

	# define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE( \
	z, n, args \
	) \
	template< typename U > \
	struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< \
	U \
	, typename \
	BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
	args, n \
	)< \
	BOOST_MSVC_TYPENAME U::BOOST_PP_ARRAY_ELEM(1, args)< > \
	>::type \
	> { \
	BOOST_STATIC_CONSTANT(bool, value = true); \
	typedef boost::mpl::bool_< value > type; \
	}; \
	/**/

	# define BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE( \
	args, member_macro \
	) \
	BOOST_PP_REPEAT( \
	BOOST_PP_ARRAY_ELEM(2, args) \
	, BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE \
	, args \
	) \
	/**/

	# define BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE( \
	args, substitute_macro, member_macro \
	) \
	BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE(args, member_macro) \
	BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE(args, member_macro) \
	template< typename U > \
	struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \
	: BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U > { \
	}; \
	/**/

	// BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE expands to the full
	// implementation of the template-based metafunction. Compile with -E
	// to see the preprocessor output for this macro.
	//
	// Note that if BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE is
	// defined BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE needs
	// to be expanded at namespace level before
	// BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE can be used.
	# define BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \
	args, substitute_macro, member_macro \
	) \
	BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \
	args, substitute_macro \
	) \
	BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \
	args \
	, BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE \
	, substitute_macro \
	, member_macro \
	) \
	/**/

	# endif // BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE

	// Note: In the current implementation the parameter and access macros
	// are no longer expanded.
	# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
	# define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \
	BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \
	( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \
	, BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \
	, BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \
	) \
	/**/
	# else
	# define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \
	BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \
	( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \
	, BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \
	, BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \
	) \
	/**/
	# endif

	#else // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE

	// placeholder implementation

	# define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \
	template< typename T \
	, typename fallback_ = boost::mpl::bool_< default_ > > \
	struct trait { \
	BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \
	typedef fallback_ type; \
	}; \
	/**/

	#endif // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE

	# define BOOST_MPL_HAS_XXX_TEMPLATE_DEF(name) \
	BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF( \
	BOOST_PP_CAT(has_, name), name, false \
	) \
	/**/

	#endif // BOOST_MPL_HAS_XXX_HPP_INCLUDED