diff options
| author | robot-contrib <robot-contrib@yandex-team.com> | 2022-08-07 15:51:22 +0300 |
|---|---|---|
| committer | robot-contrib <robot-contrib@yandex-team.com> | 2022-08-07 15:51:22 +0300 |
| commit | 8b163f003d8db5f6520630da7e2e6b393bfb2b5c (patch) | |
| tree | 91352768bd73d5f49b35ce9733790acf4d17c935 | |
| parent | 5916f81090c43c352126d22287fde40f71aeee95 (diff) | |
| download | ydb-8b163f003d8db5f6520630da7e2e6b393bfb2b5c.tar.gz | |
Update contrib/restricted/boost/type_traits to 1.79.0
81 files changed, 4670 insertions, 2169 deletions
diff --git a/contrib/restricted/boost/type_traits/README.md b/contrib/restricted/boost/type_traits/README.md new file mode 100644 index 00000000000..62b1329b722 --- /dev/null +++ b/contrib/restricted/boost/type_traits/README.md @@ -0,0 +1,47 @@ +Boost TypeTraits Library +============================ + +The Boost type-traits library contains a set of very specific traits classes, each of which encapsulate a single trait +from the C++ type system; for example, is a type a pointer or a reference type? Or does a type have a trivial constructor, or a const-qualifier? + +The type-traits classes share a unified design: each class inherits from the type true_type if the type has the specified property and inherits from false_type otherwise. + +The type-traits library also contains a set of classes that perform a specific transformation on a type; for example, they can remove a top-level const or +volatile qualifier from a type. Each class that performs a transformation defines a single typedef-member type that is the result of the transformation. + +The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/type_traits/index.html). + +| | Master | Develop | +|------------------|----------|-------------| +| Travis | [](https://travis-ci.org/boostorg/type_traits) | [](https://travis-ci.org/boostorg/type_traits) | +| Appveyor | [](https://ci.appveyor.com/project/jzmaddock/type-traits/branch/master) | [](https://ci.appveyor.com/project/jzmaddock/type-traits/branch/develop) | + + +## Support, bugs and feature requests ## + +Bugs and feature requests can be reported through the [Gitub issue tracker](https://github.com/boostorg/type_traits/issues) +(see [open issues](https://github.com/boostorg/type_traits/issues) and +[closed issues](https://github.com/boostorg/type_traits/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aclosed)). + +You can submit your changes through a [pull request](https://github.com/boostorg/type_traits/pulls). + +There is no mailing-list specific to Boost TypeTraits, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [type_traits]. + + +## Development ## + +Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)): + + git clone https://github.com/boostorg/boost + cd boost + git submodule update --init + +The Boost TypeTraits Library is located in `libs/type_traits/`. + +### Running tests ### +First, make sure you are in `libs/type_traits/test`. +You can either run all the tests listed in `Jamfile.v2` or run a single test: + + ../../../b2 <- run all tests + ../../../b2 config_info <- single test + diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits.hpp index 9f024b1028c..a1c882e03b8 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits.hpp @@ -21,9 +21,14 @@ #include <boost/type_traits/alignment_of.hpp> #include <boost/type_traits/common_type.hpp> #include <boost/type_traits/conditional.hpp> +#include <boost/type_traits/conjunction.hpp> #include <boost/type_traits/copy_cv.hpp> +#include <boost/type_traits/copy_cv_ref.hpp> +#include <boost/type_traits/copy_reference.hpp> #include <boost/type_traits/decay.hpp> #include <boost/type_traits/declval.hpp> +#include <boost/type_traits/disjunction.hpp> +#include <boost/type_traits/enable_if.hpp> #include <boost/type_traits/extent.hpp> #include <boost/type_traits/floating_point_promotion.hpp> #include <boost/type_traits/function_traits.hpp> @@ -55,7 +60,7 @@ #include <boost/type_traits/has_multiplies.hpp> #include <boost/type_traits/has_multiplies_assign.hpp> #include <boost/type_traits/has_negate.hpp> -#if !defined(__BORLANDC__) && !defined(__CUDACC__) +#if !defined(BOOST_BORLANDC) && (!(defined(__CUDACC__) && (__CUDACC_VER_MAJOR__ < 11)) || defined(__CUDA__)) #include <boost/type_traits/has_new_operator.hpp> #endif #include <boost/type_traits/has_not_equal_to.hpp> @@ -123,9 +128,12 @@ #include <boost/type_traits/is_rvalue_reference.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/is_scalar.hpp> +#include <boost/type_traits/is_scoped_enum.hpp> #include <boost/type_traits/is_signed.hpp> #include <boost/type_traits/is_stateless.hpp> +#include <boost/type_traits/is_trivially_copyable.hpp> #include <boost/type_traits/is_union.hpp> +#include <boost/type_traits/is_unscoped_enum.hpp> #include <boost/type_traits/is_unsigned.hpp> #include <boost/type_traits/is_virtual_base_of.hpp> #include <boost/type_traits/is_void.hpp> @@ -133,6 +141,7 @@ #include <boost/type_traits/make_signed.hpp> #include <boost/type_traits/make_unsigned.hpp> #include <boost/type_traits/make_void.hpp> +#include <boost/type_traits/negation.hpp> #include <boost/type_traits/rank.hpp> #include <boost/type_traits/remove_all_extents.hpp> #include <boost/type_traits/remove_bounds.hpp> diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/add_pointer.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/add_pointer.hpp index 85ad33a8d97..80b0703707e 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/add_pointer.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/add_pointer.hpp @@ -13,7 +13,7 @@ namespace boost { -#if defined(__BORLANDC__) && (__BORLANDC__ < 0x5A0) +#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x5A0) // // For some reason this implementation stops Borlands compiler // from dropping cv-qualifiers, it still fails with references diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/aligned_storage.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/aligned_storage.hpp index 171f5d450b0..8ad00a20e04 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/aligned_storage.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/aligned_storage.hpp @@ -73,7 +73,7 @@ template < , std::size_t alignment_ = std::size_t(-1) > class aligned_storage : -#ifndef __BORLANDC__ +#ifndef BOOST_BORLANDC private #else public diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/alignment_of.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/alignment_of.hpp index 7d960e31840..baa3f4d95b0 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/alignment_of.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/alignment_of.hpp @@ -19,7 +19,7 @@ # pragma warning(push) # pragma warning(disable: 4121 4512) // alignment is sensitive to packing #endif -#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x600) #pragma option push -Vx- -Ve- #endif @@ -91,7 +91,7 @@ template <class T> struct alignment_of : public integral_constant<std::size_t, : // that a reference is just a special pointer: template <typename T> struct alignment_of<T&> : public alignment_of<T*>{}; -#ifdef __BORLANDC__ +#ifdef BOOST_BORLANDC // long double gives an incorrect value of 10 (!) // unless we do this... struct long_double_wrapper{ long double ld; }; @@ -108,7 +108,7 @@ template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0 } // namespace boost -#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x600) #pragma option pop #endif #ifdef BOOST_MSVC diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/conjunction.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/conjunction.hpp new file mode 100644 index 00000000000..aa5440b60e1 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/conjunction.hpp @@ -0,0 +1,40 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ + +#ifndef BOOST_TT_CONJUNCTION_HPP_INCLUDED +#define BOOST_TT_CONJUNCTION_HPP_INCLUDED + +#include <boost/type_traits/conditional.hpp> +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +#include <boost/type_traits/integral_constant.hpp> +#endif + +namespace boost { + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +template<class...> +struct conjunction + : true_type { }; + +template<class T> +struct conjunction<T> + : T { }; + +template<class T, class... U> +struct conjunction<T, U...> + : conditional<bool(T::value), conjunction<U...>, T>::type { }; +#else +template<class T, class U> +struct conjunction + : conditional<bool(T::value), U, T>::type { }; +#endif + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/copy_cv_ref.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/copy_cv_ref.hpp new file mode 100644 index 00000000000..59cbc66e998 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/copy_cv_ref.hpp @@ -0,0 +1,31 @@ +/* +Copyright 2019 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ +#ifndef BOOST_TT_COPY_CV_REF_HPP_INCLUDED +#define BOOST_TT_COPY_CV_REF_HPP_INCLUDED + +#include <boost/type_traits/copy_cv.hpp> +#include <boost/type_traits/copy_reference.hpp> +#include <boost/type_traits/remove_reference.hpp> + +namespace boost { + +template<class T, class U> +struct copy_cv_ref { + typedef typename copy_reference<typename copy_cv<T, + typename remove_reference<U>::type >::type, U>::type type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template<class T, class U> +using copy_cv_ref_t = typename copy_cv_ref<T, U>::type; +#endif + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/copy_reference.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/copy_reference.hpp new file mode 100644 index 00000000000..005668142a4 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/copy_reference.hpp @@ -0,0 +1,35 @@ +/* +Copyright 2019 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ +#ifndef BOOST_TT_COPY_REFERENCE_HPP_INCLUDED +#define BOOST_TT_COPY_REFERENCE_HPP_INCLUDED + +#include <boost/type_traits/add_lvalue_reference.hpp> +#include <boost/type_traits/add_rvalue_reference.hpp> +#include <boost/type_traits/is_lvalue_reference.hpp> +#include <boost/type_traits/is_rvalue_reference.hpp> +#include <boost/type_traits/conditional.hpp> + +namespace boost { + +template<class T, class U> +struct copy_reference { + typedef typename conditional<is_rvalue_reference<U>::value, + typename add_rvalue_reference<T>::type, + typename conditional<is_lvalue_reference<U>::value, + typename add_lvalue_reference<T>::type, T>::type>::type type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template<class T, class U> +using copy_reference_t = typename copy_reference<T, U>::type; +#endif + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/common_arithmetic_type.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/common_arithmetic_type.hpp index a7aff039297..1a76e16d3ff 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/common_arithmetic_type.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/common_arithmetic_type.hpp @@ -206,9 +206,11 @@ private: static bool cond(); + BOOST_STATIC_CONSTANT(int, selector = sizeof(select(cond() ? T() : U()))); + public: - typedef typename arithmetic_type< sizeof(select( cond()? T(): U() )) >::type type; + typedef typename arithmetic_type<selector>::type type; }; } // namespace type_traits_detail diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/config.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/config.hpp index 2113c438a5e..679ad08bdf6 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/config.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/config.hpp @@ -20,7 +20,7 @@ // it needs to be declared __cdecl to suppress compiler // warnings from MS and Borland compilers (this *must* // appear before we include is_same.hpp below): -#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32)) +#if defined(BOOST_MSVC) || (defined(BOOST_BORLANDC) && !defined(BOOST_DISABLE_WIN32)) # define BOOST_TT_DECL __cdecl #else # define BOOST_TT_DECL /**/ @@ -28,7 +28,7 @@ # if (BOOST_WORKAROUND(__MWERKS__, < 0x3000) \ || BOOST_WORKAROUND(__IBMCPP__, < 600 ) \ - || BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \ + || BOOST_WORKAROUND(BOOST_BORLANDC, < 0x5A0) \ || defined(__ghs) \ || BOOST_WORKAROUND(__HP_aCC, < 60700) \ || BOOST_WORKAROUND(MPW_CPLUS, BOOST_TESTED_AT(0x890)) \ @@ -48,7 +48,7 @@ // when we want to test __stdcall etc function types with is_function etc // (Note, does not work with Borland, even though it does support __stdcall etc): // -#if defined(_MSC_EXTENSIONS) && !defined(__BORLANDC__) +#if defined(_MSC_EXTENSIONS) && !defined(BOOST_BORLANDC) # define BOOST_TT_TEST_MS_FUNC_SIGS #endif @@ -78,6 +78,39 @@ #undef BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION #endif +// +// Can we implement accurate is_function/is_member_function_pointer (post C++03)? +// +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !BOOST_WORKAROUND(BOOST_GCC, < 40805)\ + && !BOOST_WORKAROUND(BOOST_MSVC, < 1900) && !BOOST_WORKAROUND(__clang_major__, <= 4) +# define BOOST_TT_HAS_ACCURATE_IS_FUNCTION +#endif + +#if defined(_MSVC_LANG) && (_MSVC_LANG >= 201703) +# define BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM +#endif +#if defined(__APPLE_CC__) && defined(__clang_major__) && (__clang_major__ == 9) && (__clang_minor__ == 0) +# define BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM +# define BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE +#endif +// +// If we have the SD6 macros (check for C++11's __cpp_rvalue_references), and we don't have __cpp_noexcept_function_type +// set, then don't treat noexcept functions as seperate types. This is a fix for msvc with the /Zc:noexceptTypes- flag set. +// +#if defined(__cpp_rvalue_references) && !defined(__cpp_noexcept_function_type) && !defined(BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE) +# define BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE +#endif +// +// Check MSVC specific macro on older msvc compilers that don't support the SD6 macros, we don't rely on this +// if the SD6 macros *are* available as it appears to be undocumented. +// +#if defined(BOOST_MSVC) && !defined(__cpp_rvalue_references) && !defined(BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE) && !defined(_NOEXCEPT_TYPES_SUPPORTED) +# define BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE +#endif +#if defined(__cpp_rvalue_references) && defined(__NVCC__) && defined(__CUDACC__) && !defined(BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE) +# define BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE +#endif + #endif // BOOST_TT_CONFIG_HPP_INCLUDED diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_binary_operator.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_binary_operator.hpp index ec6e52e73ba..7e74705eb35 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_binary_operator.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_binary_operator.hpp @@ -47,25 +47,25 @@ namespace boost struct dont_care; - template <class T, class U, class Ret, class = boost::void_t<>> + template <class T, class U, class Ret, class = void> struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) : public boost::false_type {}; template <class T, class U, class Ret> - struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp)<T, U, Ret, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())> > + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp)<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type> : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>()), Ret>::value> {}; - template <class T, class U, class = boost::void_t<> > + template <class T, class U, class = void > struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) : public boost::false_type {}; template <class T, class U> - struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp)<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())> > + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp)<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type> : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::value> {}; - template <class T, class U, class = boost::void_t<>> + template <class T, class U, class = void> struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) : public boost::false_type {}; template <class T, class U> - struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp)<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())> > + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp)<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type> : public boost::true_type {}; } diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_postfix_operator.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_postfix_operator.hpp index ba0358fe402..d900acd3d43 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_postfix_operator.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_postfix_operator.hpp @@ -7,6 +7,59 @@ // See http://www.boost.org/libs/type_traits for most recent version including documentation. #include <boost/config.hpp> +#include <boost/type_traits/detail/config.hpp> + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include <boost/type_traits/integral_constant.hpp> +#include <boost/type_traits/make_void.hpp> +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/is_void.hpp> +#include <boost/type_traits/add_reference.hpp> +#include <utility> + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template <class T, class Ret, class = void> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) : public boost::false_type {}; + + template <class T, class Ret> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp)<T, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP) >::type> + : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP), Ret>::value> {}; + + template <class T, class = void > + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) : public boost::false_type {}; + + template <class T> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp)<T, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>()BOOST_TT_TRAIT_OP)>::type> + : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP)>::value> {}; + + template <class T, class = void> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) : public boost::false_type {}; + + template <class T> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp)<T, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP)>::type> + : public boost::true_type {}; + + } + + template <class T, class Ret = boost::binary_op_detail::dont_care> + struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, Ret> {}; + template <class T> + struct BOOST_TT_TRAIT_NAME<T, void> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T> {}; + template <class T> + struct BOOST_TT_TRAIT_NAME<T, boost::binary_op_detail::dont_care> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T> {}; + + +} + +#else + #include <boost/type_traits/detail/yes_no_type.hpp> #include <boost/type_traits/integral_constant.hpp> #include <boost/type_traits/is_const.hpp> @@ -193,3 +246,5 @@ struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BO #if defined(BOOST_MSVC) # pragma warning ( pop ) #endif + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_prefix_operator.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_prefix_operator.hpp index a246c60300b..77818c20fb6 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_prefix_operator.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/has_prefix_operator.hpp @@ -7,6 +7,75 @@ // See http://www.boost.org/libs/type_traits for most recent version including documentation. #include <boost/config.hpp> +#include <boost/type_traits/detail/config.hpp> + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include <boost/type_traits/integral_constant.hpp> +#include <boost/type_traits/make_void.hpp> +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/is_void.hpp> +#include <boost/type_traits/add_reference.hpp> +#include <utility> + +#ifdef BOOST_GCC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated" +#endif +#if defined(BOOST_MSVC) +# pragma warning ( push ) +# pragma warning ( disable : 4804) +#endif + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template <class T, class Ret, class = void> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) : public boost::false_type {}; + + template <class T, class Ret> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp)<T, Ret, typename boost::make_void<decltype(BOOST_TT_TRAIT_OP std::declval<typename add_reference<T>::type>()) >::type> + : public boost::integral_constant<bool, ::boost::is_convertible<decltype(BOOST_TT_TRAIT_OP std::declval<typename add_reference<T>::type>() ), Ret>::value> {}; + + template <class T, class = void > + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) : public boost::false_type {}; + + template <class T> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp)<T, typename boost::make_void<decltype(BOOST_TT_TRAIT_OP std::declval<typename add_reference<T>::type>())>::type> + : public boost::integral_constant<bool, ::boost::is_void<decltype(BOOST_TT_TRAIT_OP std::declval<typename add_reference<T>::type>())>::value> {}; + + template <class T, class = void> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) : public boost::false_type {}; + + template <class T> + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp)<T, typename boost::make_void<decltype(BOOST_TT_TRAIT_OP std::declval<typename add_reference<T>::type>() )>::type> + : public boost::true_type {}; + + } + + template <class T, class Ret = boost::binary_op_detail::dont_care> + struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, Ret> {}; + template <class T> + struct BOOST_TT_TRAIT_NAME<T, void> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T> {}; + template <class T> + struct BOOST_TT_TRAIT_NAME<T, boost::binary_op_detail::dont_care> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T> {}; + + +} + +#ifdef BOOST_GCC +#pragma GCC diagnostic pop +#endif +#if defined(BOOST_MSVC) +# pragma warning ( pop ) +#endif + +#else + #include <boost/type_traits/detail/yes_no_type.hpp> #include <boost/type_traits/integral_constant.hpp> #include <boost/type_traits/is_const.hpp> @@ -206,3 +275,6 @@ struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BO #if defined(BOOST_MSVC) # pragma warning ( pop ) #endif + +#endif + diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_cxx_03.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_cxx_03.hpp new file mode 100644 index 00000000000..1b6169ab6de --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_cxx_03.hpp @@ -0,0 +1,108 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// Copyright 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) +// +// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_FUNCTION_CXX_03_HPP_INCLUDED +#define BOOST_TT_IS_FUNCTION_CXX_03_HPP_INCLUDED + +#include <boost/type_traits/is_reference.hpp> + +#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS) +# include <boost/type_traits/detail/is_function_ptr_helper.hpp> +#else +# include <boost/type_traits/detail/is_function_ptr_tester.hpp> +# include <boost/type_traits/detail/yes_no_type.hpp> +#endif + +// is a type a function? +// Please note that this implementation is unnecessarily complex: +// we could just use !is_convertible<T*, const volatile void*>::value, +// except that some compilers erroneously allow conversions from +// function pointers to void*. + +namespace boost { + +#if !defined( BOOST_CODEGEARC ) + +namespace detail { + +#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS) +template<bool is_ref = true> +struct is_function_chooser +{ + template< typename T > struct result_ + : public false_type {}; +}; + +template <> +struct is_function_chooser<false> +{ + template< typename T > struct result_ + : public ::boost::type_traits::is_function_ptr_helper<T*> {}; +}; + +template <typename T> +struct is_function_impl + : public is_function_chooser< ::boost::is_reference<T>::value > + ::BOOST_NESTED_TEMPLATE result_<T> +{ +}; + +#else + +template <typename T> +struct is_function_impl +{ +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(push) +#pragma warning(disable:6334) +#endif + static T* t; + BOOST_STATIC_CONSTANT( + bool, value = sizeof(::boost::type_traits::is_function_ptr_tester(t)) + == sizeof(::boost::type_traits::yes_type) + ); +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(pop) +#endif +}; + +template <typename T> +struct is_function_impl<T&> : public false_type +{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template <typename T> +struct is_function_impl<T&&> : public false_type +{}; +#endif + +#endif + +} // namespace detail + +#endif // !defined( BOOST_CODEGEARC ) + +#if defined( BOOST_CODEGEARC ) +template <class T> struct is_function : integral_constant<bool, __is_function(T)> {}; +#else +template <class T> struct is_function : integral_constant<bool, ::boost::detail::is_function_impl<T>::value> {}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template <class T> struct is_function<T&&> : public false_type {}; +#endif +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1600) +template <class T> struct is_function<T&> : public false_type {}; +#endif +#endif +} // namespace boost + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1700) +#include <boost/type_traits/detail/is_function_msvc10_fix.hpp> +#endif + +#endif // BOOST_TT_IS_FUNCTION_CXX_03_HPP_INCLUDED diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_cxx_11.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_cxx_11.hpp new file mode 100644 index 00000000000..2dbe1de0eed --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_cxx_11.hpp @@ -0,0 +1,676 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// Copyright 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) +// +// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_FUNCTION_CXX_11_HPP_INCLUDED +#define BOOST_TT_IS_FUNCTION_CXX_11_HPP_INCLUDED + +#include <boost/type_traits/integral_constant.hpp> + +namespace boost { + + template <class T> + struct is_function : public false_type {}; + +#if defined(__cpp_noexcept_function_type) && !defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM) +#define BOOST_TT_NOEXCEPT_PARAM , bool NE +#define BOOST_TT_NOEXCEPT_DECL noexcept(NE) +#else +#define BOOST_TT_NOEXCEPT_PARAM +#define BOOST_TT_NOEXCEPT_DECL +#endif + +#ifdef _MSC_VER +#define BOOST_TT_DEF_CALL __cdecl +#else +#define BOOST_TT_DEF_CALL +#endif + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + // Reference qualified: + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + // rvalue reference qualified: + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)&& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)&& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + +#if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) + +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_X64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const: + +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // reference qualified: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // rvalue reference qualified: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + +#endif // _MSC_VER + + // All over again for msvc with noexcept: + +#if defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM) && !defined(BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE) + +#undef BOOST_TT_NOEXCEPT_DECL +#define BOOST_TT_NOEXCEPT_DECL noexcept + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + // Reference qualified: + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + // rvalue reference qualified: + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif + template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + +#if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) + +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // reference qualified: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // rvalue reference qualified: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __clrcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __fastcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_function<Ret __vectorcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + +#endif // defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) + +#endif + +} + +#undef BOOST_TT_NOEXCEPT_DECL +#undef BOOST_TT_NOEXCEPT_PARAM +#undef BOOST_TT_DEF_CALL + +#endif // BOOST_TT_IS_FUNCTION_CXX_11_HPP_INCLUDED + diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_msvc10_fix.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_msvc10_fix.hpp new file mode 100644 index 00000000000..ec8ba9ad32e --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_msvc10_fix.hpp @@ -0,0 +1,30 @@ + +// (C) Copyright John Maddock 2018. +// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_FUNCTION_MSVC10_FIX_HPP_INCLUDED +#define BOOST_TT_IS_FUNCTION_MSVC10_FIX_HPP_INCLUDED + +namespace boost { + +template <class R> struct is_function<R(&&)()> : public false_type {}; +template <class R> struct is_function<R(&&)(...)> : public false_type {}; +template <class R, class Arg1> struct is_function<R(&&)(Arg1)> : public false_type {}; +template <class R, class Arg1> struct is_function<R(&&)(Arg1, ...)> : public false_type {}; +template <class R, class Arg1, class Arg2> struct is_function<R(&&)(Arg1, Arg2)> : public false_type {}; +template <class R, class Arg1, class Arg2> struct is_function<R(&&)(Arg1, Arg2, ...)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3> struct is_function<R(&&)(Arg1, Arg2, Arg3)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3> struct is_function<R(&&)(Arg1, Arg2, Arg3, ...)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_function<R(&&)(Arg1, Arg2, Arg3, Arg4)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_function<R(&&)(Arg1, Arg2, Arg3, Arg4, ...)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_function<R(&&)(Arg1, Arg2, Arg3, Arg4, Arg5)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_function<R(&&)(Arg1, Arg2, Arg3, Arg4, Arg5, ...)> : public false_type {}; + +} // namespace boost + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_ptr_tester.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_ptr_tester.hpp index 4fe88e81b2c..1c8683c04db 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_ptr_tester.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_function_ptr_tester.hpp @@ -44,368 +44,524 @@ no_type BOOST_TT_DECL is_function_ptr_tester(...); // cpp -I../../../ -DBOOST_TT_PREPROCESSING_MODE -x c++ -P filename template <class R > -yes_type is_function_ptr_tester(R (*)()); +yes_type is_function_ptr_tester(R(*)()); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template <class R > -yes_type is_function_ptr_tester(R (*)( ...)); +yes_type is_function_ptr_tester(R(*)(...)); +#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template <class R > -yes_type is_function_ptr_tester(R (__stdcall*)()); +yes_type is_function_ptr_tester(R(__stdcall*)()); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R > +yes_type is_function_ptr_tester(R(__vectorcall*)()); +#endif #ifndef _MANAGED template <class R > -yes_type is_function_ptr_tester(R (__fastcall*)()); +yes_type is_function_ptr_tester(R(__fastcall*)()); #endif template <class R > -yes_type is_function_ptr_tester(R (__cdecl*)()); +yes_type is_function_ptr_tester(R(__cdecl*)()); +#endif +template <class R, class T0 > +yes_type is_function_ptr_tester(R(*)(T0)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0 > +yes_type is_function_ptr_tester(R(*)(T0 ...)); #endif -template <class R , class T0 > -yes_type is_function_ptr_tester(R (*)( T0)); -template <class R , class T0 > -yes_type is_function_ptr_tester(R (*)( T0 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0)); +template <class R, class T0 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0)); +#endif #ifndef _MANAGED -template <class R , class T0 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0)); +template <class R, class T0 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0)); +#endif +template <class R, class T0 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0)); #endif -template <class R , class T0 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0)); +template <class R, class T0, class T1 > +yes_type is_function_ptr_tester(R(*)(T0, T1)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1 > +yes_type is_function_ptr_tester(R(*)(T0, T1 ...)); #endif -template <class R , class T0 , class T1 > -yes_type is_function_ptr_tester(R (*)( T0 , T1)); -template <class R , class T0 , class T1 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1)); +template <class R, class T0, class T1 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1)); +template <class R, class T0, class T1 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1)); #endif -template <class R , class T0 , class T1 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1)); +template <class R, class T0, class T1 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1)); +#endif +template <class R, class T0, class T1, class T2 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2 ...)); #endif -template <class R , class T0 , class T1 , class T2 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2)); -template <class R , class T0 , class T1 , class T2 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2)); +template <class R, class T0, class T1, class T2 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2)); +template <class R, class T0, class T1, class T2 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2)); #endif -template <class R , class T0 , class T1 , class T2 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2)); +template <class R, class T0, class T1, class T2 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2)); +#endif +template <class R, class T0, class T1, class T2, class T3 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3)); -template <class R , class T0 , class T1 , class T2 , class T3 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3)); +template <class R, class T0, class T1, class T2, class T3 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3)); +template <class R, class T0, class T1, class T2, class T3 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3)); +template <class R, class T0, class T1, class T2, class T3 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4)); +template <class R, class T0, class T1, class T2, class T3, class T4 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4)); +template <class R, class T0, class T1, class T2, class T3, class T4 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +#endif +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); +#endif #ifndef _MANAGED -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_function_ptr_tester(R(__fastcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); #endif -template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); +template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_function_ptr_tester(R(__cdecl*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); #endif #else @@ -437,6 +593,10 @@ yes_type is_function_ptr_tester(R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) . @#ifdef BOOST_TT_TEST_MS_FUNC_SIGS template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) > yes_type is_function_ptr_tester(R (__stdcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); +@#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, class T) > +yes_type is_function_ptr_tester(R(__vectorcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, T))); +@#endif @#ifndef _MANAGED template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) > yes_type is_function_ptr_tester(R (__fastcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_likely_lambda.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_likely_lambda.hpp index 6da8acafce6..893b4ba054d 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_likely_lambda.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_likely_lambda.hpp @@ -27,10 +27,11 @@ struct is_likely_stateless_lambda : public false_type {}; }} -#elif !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !BOOST_WORKAROUND(BOOST_MSVC, < 1900) +#elif !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !BOOST_WORKAROUND(BOOST_MSVC, < 1900)\ + && !(BOOST_WORKAROUND(BOOST_MSVC, == 1900) && defined(_MANAGED)) #include <boost/type_traits/is_convertible.hpp> -#include <boost/core/enable_if.hpp> +#include <boost/type_traits/enable_if.hpp> namespace boost{ @@ -70,7 +71,7 @@ struct is_likely_stateless_lambda : false_type{}; template<typename T> struct is_likely_stateless_lambda< T, - typename boost::enable_if_c<has_one_operator_call<T>::value>::type> : + typename boost::enable_if_<has_one_operator_call<T>::value>::type> : boost::is_convertible<T, typename equivalent_function_pointer<T>::type >{}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp index c186db7bacf..083a10fd25c 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp @@ -43,1669 +43,1460 @@ no_type BOOST_TT_DECL is_mem_fun_pointer_tester(...); // cpp -I../../../ -DBOOST_TT_PREPROCESSING_MODE -x c++ -P filename template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)()); - +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)()); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() const); - +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)() const); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() volatile); - +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)() volatile); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() const volatile); - +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)() const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...)); - +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(...)); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) const); - +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(...) const); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) volatile); - +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(...) volatile); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) const volatile); +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(...) const volatile); +#endif #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)()); - +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)()); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() const); - +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)() const); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() volatile); - +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)() volatile); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() const volatile); - +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)() const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)()); +template <class R, class T > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)() const); +template <class R, class T > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)() volatile); +template <class R, class T > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)() const volatile); +#endif #ifndef _MANAGED template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)()); - +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)()); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() const); - +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)() const); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() volatile); - +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)() volatile); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() const volatile); - +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)() const volatile); #endif - template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)()); - +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)()); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() const); - +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)() const); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() volatile); - +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)() volatile); template <class R, class T > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() const volatile); - +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)() const volatile); +#endif +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0)); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0) const); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0) volatile); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0 ...)); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0 ...) const); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0 ...) volatile); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0 ...) const volatile); #endif -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0)); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) const); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) volatile); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) const volatile); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...)); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) const); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) volatile); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0)); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) const); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) volatile); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) const volatile); - +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0)); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0) const); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0) volatile); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0)); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0) const); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0) volatile); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0)); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) const); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) volatile); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) const volatile); - +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0)); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0) const); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0) volatile); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0) const volatile); #endif - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0)); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) const); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) volatile); - -template <class R, class T , class T0 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) const volatile); - +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0)); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0) const); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0) volatile); +template <class R, class T, class T0 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0) const volatile); +#endif +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1)); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1) const); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1) volatile); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1 ...)); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1 ...) const); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1 ...) volatile); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1)); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) const); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) volatile); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) const volatile); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...)); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) const); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) volatile); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1)); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) const); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) volatile); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) const volatile); - +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1)); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1) const); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1) volatile); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1)); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1) const); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1) volatile); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1)); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) const); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) volatile); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) const volatile); - +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1)); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1) const); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1) volatile); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1) const volatile); #endif - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1)); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) const); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) volatile); - -template <class R, class T , class T0 , class T1 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) const volatile); - +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1)); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1) const); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1) volatile); +template <class R, class T, class T0, class T1 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2)); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2) const); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2) volatile); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2 ...)); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2 ...) const); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2 ...) volatile); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2)); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) const); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) volatile); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...)); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2)); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) const); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) volatile); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) const volatile); - +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2)); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2) const); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2) volatile); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2)); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2) const); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2) volatile); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2)); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) const); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) volatile); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) const volatile); - +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2)); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2) const); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2) volatile); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2)); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) const); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) volatile); - -template <class R, class T , class T0 , class T1 , class T2 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) const volatile); - +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2)); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2) const); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2) volatile); +template <class R, class T, class T0, class T1, class T2 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3)); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3) const); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3) volatile); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3 ...)); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3)); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3) const); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3) volatile); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3)); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3) const); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3) volatile); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3)); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3) const); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3) volatile); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3)); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3) const); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3) volatile); +template <class R, class T, class T0, class T1, class T2, class T3 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile); - #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const volatile); +#endif +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const volatile); +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const volatile); #endif -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const volatile); +#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const volatile); +#endif #ifndef _MANAGED -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__fastcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const volatile); #endif - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile); - -template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 > -yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); - +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) volatile); +template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24 > +yes_type is_mem_fun_pointer_tester(R(__cdecl T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const volatile); #endif #else @@ -1766,7 +1557,19 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_EN template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) > yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); +@#if (_MSC_VER >= 1800) && !defined(_MANAGED) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) > +yes_type is_mem_fun_pointer_tester(R (__vectorcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); + +template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) > +yes_type is_mem_fun_pointer_tester(R (__vectorcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const); +template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) > +yes_type is_mem_fun_pointer_tester(R (__vectorcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile); + +template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) > +yes_type is_mem_fun_pointer_tester(R (__vectorcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); +@#endif @#ifndef _MANAGED template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) > yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp new file mode 100644 index 00000000000..7dbee1d1b8f --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp @@ -0,0 +1,117 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_MEMBER_FUNCTION_POINTER_CXX_03_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_CXX_03_HPP_INCLUDED + +#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) + // + // Note: we use the "workaround" version for MSVC because it works for + // __stdcall etc function types, where as the partial specialisation + // version does not do so. + // +# include <boost/type_traits/detail/is_mem_fun_pointer_impl.hpp> +# include <boost/type_traits/remove_cv.hpp> +# include <boost/type_traits/integral_constant.hpp> +#else +# include <boost/type_traits/is_reference.hpp> +# include <boost/type_traits/is_array.hpp> +# include <boost/type_traits/detail/yes_no_type.hpp> +# include <boost/type_traits/detail/is_mem_fun_pointer_tester.hpp> +#endif + +namespace boost { + +#if defined( BOOST_CODEGEARC ) +template <class T> struct is_member_function_pointer : public integral_constant<bool, __is_member_function_pointer( T )> {}; +#elif !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) + +template <class T> struct is_member_function_pointer + : public ::boost::integral_constant<bool, ::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value>{}; + +#else + +namespace detail { + +#ifndef BOOST_BORLANDC + +template <bool> +struct is_mem_fun_pointer_select +{ + template <class T> struct result_ : public false_type{}; +}; + +template <> +struct is_mem_fun_pointer_select<false> +{ + template <typename T> struct result_ + { +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(push) +#pragma warning(disable:6334) +#endif + static T* make_t; + typedef result_<T> self_type; + + BOOST_STATIC_CONSTANT( + bool, value = ( + 1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(self_type::make_t)) + )); +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(pop) +#endif + }; +}; + +template <typename T> +struct is_member_function_pointer_impl + : public is_mem_fun_pointer_select< + ::boost::is_reference<T>::value || ::boost::is_array<T>::value>::template result_<T>{}; + +template <typename T> +struct is_member_function_pointer_impl<T&> : public false_type{}; + +#else // Borland C++ + +template <typename T> +struct is_member_function_pointer_impl +{ + static T* m_t; + BOOST_STATIC_CONSTANT( + bool, value = + (1 == sizeof(type_traits::is_mem_fun_pointer_tester(m_t))) ); +}; + +template <typename T> +struct is_member_function_pointer_impl<T&> +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +#endif + +template<> struct is_member_function_pointer_impl<void> : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template<> struct is_member_function_pointer_impl<void const> : public false_type{}; +template<> struct is_member_function_pointer_impl<void const volatile> : public false_type{}; +template<> struct is_member_function_pointer_impl<void volatile> : public false_type{}; +#endif + +} // namespace detail + +template <class T> +struct is_member_function_pointer + : public integral_constant<bool, ::boost::detail::is_member_function_pointer_impl<T>::value>{}; + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp new file mode 100644 index 00000000000..ac3477b38ce --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp @@ -0,0 +1,697 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_MEMBER_FUNCTION_POINTER_CXX_11_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_CXX_11_HPP_INCLUDED + +#include <boost/type_traits/integral_constant.hpp> + +namespace boost { + +#ifdef _MSC_VER +#define BOOST_TT_DEF_CALL __thiscall +#else +#define BOOST_TT_DEF_CALL +#endif + + + template <class T> + struct is_member_function_pointer : public false_type {}; + template <class T> + struct is_member_function_pointer<T const> : public is_member_function_pointer<T> {}; + template <class T> + struct is_member_function_pointer<T volatile> : public is_member_function_pointer<T> {}; + template <class T> + struct is_member_function_pointer<T const volatile> : public is_member_function_pointer<T> {}; + +#if defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM) + // MSVC can't handle noexcept(b) as a deduced template parameter + // so we will have to write everything out :( +#define BOOST_TT_NOEXCEPT_PARAM +#define BOOST_TT_NOEXCEPT_DECL +#elif defined(__cpp_noexcept_function_type) +#define BOOST_TT_NOEXCEPT_PARAM , bool NE +#define BOOST_TT_NOEXCEPT_DECL noexcept(NE) +#else +#define BOOST_TT_NOEXCEPT_PARAM +#define BOOST_TT_NOEXCEPT_DECL +#endif + + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (C::*)(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + // Reference qualified: + + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + // rvalue reference qualified: + + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + +#if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__clrcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // reference qualified: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // rvalue reference qualified: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + +#endif + + +#if defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM) && !defined(BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE) + +#undef BOOST_TT_NOEXCEPT_DECL +#define BOOST_TT_NOEXCEPT_DECL noexcept + + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + // Reference qualified: + + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + + // rvalue reference qualified: + + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const qualified: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // volatile: + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + // const volatile + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + +#if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // reference qualified: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // rvalue reference qualified: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#ifdef _MANAGED + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#else +#ifndef _M_AMD64 + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) + template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM> + struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {}; +#endif +#endif + +#endif // defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) + + +#endif + +#undef BOOST_TT_NOEXCEPT_DECL +#undef BOOST_TT_NOEXCEPT_PARAM +#undef BOOST_TT_DEF_CALL +} + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_CXX_11_HPP_INCLUDED diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_rvalue_reference_msvc10_fix.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_rvalue_reference_msvc10_fix.hpp new file mode 100644 index 00000000000..d5707359b1b --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/detail/is_rvalue_reference_msvc10_fix.hpp @@ -0,0 +1,43 @@ + +// (C) Copyright John Maddock 2018. +// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_RVALUE_REFERENCE_MSVC10_FIX_HPP_INCLUDED +#define BOOST_TT_IS_RVALUE_REFERENCE_MSVC10_FIX_HPP_INCLUDED + +namespace boost { + +template <class R> struct is_rvalue_reference<R(&&)()> : public true_type {}; +template <class R> struct is_rvalue_reference<R(&&)(...)> : public true_type {}; +template <class R, class Arg1> struct is_rvalue_reference<R(&&)(Arg1)> : public true_type {}; +template <class R, class Arg1> struct is_rvalue_reference<R(&&)(Arg1, ...)> : public true_type {}; +template <class R, class Arg1, class Arg2> struct is_rvalue_reference<R(&&)(Arg1, Arg2)> : public true_type {}; +template <class R, class Arg1, class Arg2> struct is_rvalue_reference<R(&&)(Arg1, Arg2, ...)> : public true_type {}; +template <class R, class Arg1, class Arg2, class Arg3> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3)> : public true_type {}; +template <class R, class Arg1, class Arg2, class Arg3> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, ...)> : public true_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, Arg4)> : public true_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, Arg4, ...)> : public true_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, Arg4, Arg5)> : public true_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, Arg4, Arg5, ...)> : public true_type {}; + +template <class R> struct is_rvalue_reference<R(&)()> : public false_type {}; +template <class R> struct is_rvalue_reference<R(&)(...)> : public false_type {}; +template <class R, class Arg1> struct is_rvalue_reference<R(&)(Arg1)> : public false_type {}; +template <class R, class Arg1> struct is_rvalue_reference<R(&)(Arg1, ...)> : public false_type {}; +template <class R, class Arg1, class Arg2> struct is_rvalue_reference<R(&)(Arg1, Arg2)> : public false_type {}; +template <class R, class Arg1, class Arg2> struct is_rvalue_reference<R(&)(Arg1, Arg2, ...)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, ...)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, Arg4)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, Arg4, ...)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, Arg4, Arg5)> : public false_type {}; +template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, Arg4, Arg5, ...)> : public false_type {}; + +} // namespace boost + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/disjunction.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/disjunction.hpp new file mode 100644 index 00000000000..dd06991b747 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/disjunction.hpp @@ -0,0 +1,40 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ + +#ifndef BOOST_TT_DISJUNCTION_HPP_INCLUDED +#define BOOST_TT_DISJUNCTION_HPP_INCLUDED + +#include <boost/type_traits/conditional.hpp> +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +#include <boost/type_traits/integral_constant.hpp> +#endif + +namespace boost { + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +template<class...> +struct disjunction + : false_type { }; + +template<class T> +struct disjunction<T> + : T { }; + +template<class T, class... U> +struct disjunction<T, U...> + : conditional<bool(T::value), T, disjunction<U...> >::type { }; +#else +template<class T, class U> +struct disjunction + : conditional<bool(T::value), T, U>::type { }; +#endif + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/enable_if.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/enable_if.hpp new file mode 100644 index 00000000000..3cdc2816f80 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/enable_if.hpp @@ -0,0 +1,37 @@ +/* +Copyright 2003 The Trustees of Indiana University + +Authors: Jaakko Jarvi (jajarvi at osl.iu.edu) + Jeremiah Willcock (jewillco at osl.iu.edu) + Andrew Lumsdaine (lums at osl.iu.edu) + +Copyright 2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ +#ifndef BOOST_TT_ENABLE_IF_HPP_INCLUDED +#define BOOST_TT_ENABLE_IF_HPP_INCLUDED + +#include <boost/config.hpp> + +namespace boost { + +template<bool B, class T = void> +struct enable_if_ { + typedef T type; +}; + +template<class T> +struct enable_if_<false, T> { }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template<bool B, class T = void> +using enable_if_t = typename enable_if_<B, T>::type; +#endif + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/extent.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/extent.hpp index 124257878bd..2bf517fc705 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/extent.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/extent.hpp @@ -18,7 +18,7 @@ namespace boost { namespace detail{ -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) // wrap the impl as main trait provides additional MPL lambda support template < typename T, std::size_t N > struct extent_imp { @@ -81,7 +81,7 @@ struct extent_imp<T const volatile[R], 0> BOOST_STATIC_CONSTANT(std::size_t, value = R); }; -#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) && !defined(__MWERKS__) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) && !defined(__MWERKS__) template <class T, std::size_t N> struct extent_imp<T[], N> { diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_dereference.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_dereference.hpp index 1e514cdf411..3275348b717 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_dereference.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_dereference.hpp @@ -27,5 +27,349 @@ #undef BOOST_TT_TRAIT_NAME #undef BOOST_TT_TRAIT_OP #undef BOOST_TT_FORBIDDEN_IF +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) +namespace boost { + + template <class R> + struct has_dereference<void*, R> : public false_type {}; + template <> + struct has_dereference<void*, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*, R> : public false_type {}; + template <> + struct has_dereference<const void*, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*, R> : public false_type {}; + template <> + struct has_dereference<volatile void*, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*, void> : public false_type {}; + + template <class R> + struct has_dereference<void*const, R> : public false_type {}; + template <> + struct has_dereference<void*const, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*const, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*const, R> : public false_type {}; + template <> + struct has_dereference<const void*const, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*const, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*const, R> : public false_type {}; + template <> + struct has_dereference<volatile void*const, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*const, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*const, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*const, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*const, void> : public false_type {}; + + template <class R> + struct has_dereference<void*volatile, R> : public false_type {}; + template <> + struct has_dereference<void*volatile, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*volatile, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*volatile, R> : public false_type {}; + template <> + struct has_dereference<const void*volatile, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*volatile, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*volatile, R> : public false_type {}; + template <> + struct has_dereference<volatile void*volatile, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*volatile, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*volatile, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*volatile, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*volatile, void> : public false_type {}; + + template <class R> + struct has_dereference<void*const volatile, R> : public false_type {}; + template <> + struct has_dereference<void*const volatile, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*const volatile, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*const volatile, R> : public false_type {}; + template <> + struct has_dereference<const void*const volatile, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*const volatile, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*const volatile, R> : public false_type {}; + template <> + struct has_dereference<volatile void*const volatile, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*const volatile, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*const volatile, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*const volatile, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*const volatile, void> : public false_type {}; + + // references: + template <class R> + struct has_dereference<void*&, R> : public false_type {}; + template <> + struct has_dereference<void*&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*&, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*&, R> : public false_type {}; + template <> + struct has_dereference<const void*&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*&, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*&, R> : public false_type {}; + template <> + struct has_dereference<volatile void*&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*&, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*&, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*&, void> : public false_type {}; + + template <class R> + struct has_dereference<void*const&, R> : public false_type {}; + template <> + struct has_dereference<void*const&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*const&, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*const&, R> : public false_type {}; + template <> + struct has_dereference<const void*const&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*const&, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*const&, R> : public false_type {}; + template <> + struct has_dereference<volatile void*const&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*const&, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*const&, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*const&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*const&, void> : public false_type {}; + + template <class R> + struct has_dereference<void*volatile&, R> : public false_type {}; + template <> + struct has_dereference<void*volatile&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*volatile&, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*volatile&, R> : public false_type {}; + template <> + struct has_dereference<const void*volatile&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*volatile&, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*volatile&, R> : public false_type {}; + template <> + struct has_dereference<volatile void*volatile&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*volatile&, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*volatile&, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*volatile&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*volatile&, void> : public false_type {}; + + template <class R> + struct has_dereference<void*const volatile&, R> : public false_type {}; + template <> + struct has_dereference<void*const volatile&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*const volatile&, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*const volatile&, R> : public false_type {}; + template <> + struct has_dereference<const void*const volatile&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*const volatile&, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*const volatile&, R> : public false_type {}; + template <> + struct has_dereference<volatile void*const volatile&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*const volatile&, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*const volatile&, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*const volatile&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*const volatile&, void> : public false_type {}; + + // rvalue refs: + template <class R> + struct has_dereference<void*&&, R> : public false_type {}; + template <> + struct has_dereference<void*&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*&&, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*&&, R> : public false_type {}; + template <> + struct has_dereference<const void*&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*&&, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*&&, R> : public false_type {}; + template <> + struct has_dereference<volatile void*&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*&&, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*&&, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*&&, void> : public false_type {}; + + template <class R> + struct has_dereference<void*const&&, R> : public false_type {}; + template <> + struct has_dereference<void*const&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*const&&, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*const&&, R> : public false_type {}; + template <> + struct has_dereference<const void*const&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*const&&, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*const&&, R> : public false_type {}; + template <> + struct has_dereference<volatile void*const&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*const&&, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*const&&, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*const&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*const&&, void> : public false_type {}; + + template <class R> + struct has_dereference<void*volatile&&, R> : public false_type {}; + template <> + struct has_dereference<void*volatile&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*volatile&&, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*volatile&&, R> : public false_type {}; + template <> + struct has_dereference<const void*volatile&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*volatile&&, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*volatile&&, R> : public false_type {}; + template <> + struct has_dereference<volatile void*volatile&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*volatile&&, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*volatile&&, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*volatile&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*volatile&&, void> : public false_type {}; + + template <class R> + struct has_dereference<void*const volatile&&, R> : public false_type {}; + template <> + struct has_dereference<void*const volatile&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<void*const volatile&&, void> : public false_type {}; + + template <class R> + struct has_dereference<const void*const volatile&&, R> : public false_type {}; + template <> + struct has_dereference<const void*const volatile&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const void*const volatile&&, void> : public false_type {}; + + template <class R> + struct has_dereference<volatile void*const volatile&&, R> : public false_type {}; + template <> + struct has_dereference<volatile void*const volatile&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<volatile void*const volatile&&, void> : public false_type {}; + + template <class R> + struct has_dereference<const volatile void*const volatile&&, R> : public false_type {}; + template <> + struct has_dereference<const volatile void*const volatile&&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_dereference<const volatile void*const volatile&&, void> : public false_type {}; + + +} +#endif #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_minus.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_minus.hpp index ba47253ad05..fcd5d947794 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_minus.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_minus.hpp @@ -52,25 +52,25 @@ namespace boost struct dont_care; - template <class T, class U, class Ret, class = boost::void_t<>> + template <class T, class U, class Ret, class = void> struct has_minus_ret_imp : public boost::false_type {}; template <class T, class U, class Ret> - struct has_minus_ret_imp<T, U, Ret, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())> > + struct has_minus_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())>::type> : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>()), Ret>::value> {}; - template <class T, class U, class = boost::void_t<> > + template <class T, class U, class = void > struct has_minus_void_imp : public boost::false_type {}; template <class T, class U> - struct has_minus_void_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())> > + struct has_minus_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())>::type> : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())>::value> {}; - template <class T, class U, class = boost::void_t<>> + template <class T, class U, class = void> struct has_minus_dc_imp : public boost::false_type {}; template <class T, class U> - struct has_minus_dc_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())> > + struct has_minus_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())>::type> : public boost::true_type {}; template <class T, class U, class Ret> @@ -150,4 +150,9 @@ namespace boost #undef BOOST_TT_FORBIDDEN_IF #endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_minus_assign.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_minus_assign.hpp index 4f3d84fd517..ea3169e0bd6 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_minus_assign.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_minus_assign.hpp @@ -53,25 +53,25 @@ namespace boost struct dont_care; - template <class T, class U, class Ret, class = boost::void_t<>> + template <class T, class U, class Ret, class = void> struct has_minus_assign_ret_imp : public boost::false_type {}; template <class T, class U, class Ret> - struct has_minus_assign_ret_imp<T, U, Ret, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())> > + struct has_minus_assign_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())>::type> : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>()), Ret>::value> {}; - template <class T, class U, class = boost::void_t<> > + template <class T, class U, class = void > struct has_minus_assign_void_imp : public boost::false_type {}; template <class T, class U> - struct has_minus_assign_void_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())> > + struct has_minus_assign_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())>::type> : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())>::value> {}; - template <class T, class U, class = boost::void_t<>> + template <class T, class U, class = void> struct has_minus_assign_dc_imp : public boost::false_type {}; template <class T, class U> - struct has_minus_assign_dc_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())> > + struct has_minus_assign_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())>::type> : public boost::true_type {}; template <class T, class U, class Ret> @@ -155,4 +155,9 @@ namespace boost #undef BOOST_TT_FORBIDDEN_IF #endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_nothrow_copy.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_nothrow_copy.hpp index 0d9bb183790..fd9db8d8509 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_nothrow_copy.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_nothrow_copy.hpp @@ -14,7 +14,7 @@ #ifdef BOOST_HAS_NOTHROW_COPY -#if defined(BOOST_CLANG) || defined(__GNUC__) || defined(__ghs__) || defined(__CODEGEARC__) || defined(__SUNPRO_CC) +#if defined(BOOST_CLANG) || defined(__GNUC__) || defined(__ghs__) || defined(BOOST_CODEGEARC) || defined(__SUNPRO_CC) #include <boost/type_traits/is_volatile.hpp> #include <boost/type_traits/is_copy_constructible.hpp> #include <boost/type_traits/is_reference.hpp> diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_plus_assign.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_plus_assign.hpp index b4d05ad2eae..161ca158152 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_plus_assign.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_plus_assign.hpp @@ -56,25 +56,25 @@ namespace boost struct dont_care; - template <class T, class U, class Ret, class = boost::void_t<>> + template <class T, class U, class Ret, class = void> struct has_plus_assign_ret_imp : public boost::false_type {}; template <class T, class U, class Ret> - struct has_plus_assign_ret_imp<T, U, Ret, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())> > + struct has_plus_assign_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())>::type> : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>()), Ret>::value> {}; - template <class T, class U, class = boost::void_t<> > + template <class T, class U, class = void > struct has_plus_assign_void_imp : public boost::false_type {}; template <class T, class U> - struct has_plus_assign_void_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())> > + struct has_plus_assign_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())>::type> : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())>::value> {}; - template <class T, class U, class = boost::void_t<>> + template <class T, class U, class = void> struct has_plus_assign_dc_imp : public boost::false_type {}; template <class T, class U> - struct has_plus_assign_dc_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())> > + struct has_plus_assign_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())>::type> : public boost::true_type {}; template <class T, class U, class Ret> @@ -153,4 +153,9 @@ namespace boost #undef BOOST_TT_FORBIDDEN_IF #endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_post_decrement.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_post_decrement.hpp index e3f98fff1cb..fc1c430a547 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_post_decrement.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_post_decrement.hpp @@ -41,4 +41,25 @@ #undef BOOST_TT_TRAIT_OP #undef BOOST_TT_FORBIDDEN_IF +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template <class R> + struct has_post_decrement<bool, R> : public false_type {}; + template <> + struct has_post_decrement<bool, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_post_decrement<bool, void> : public false_type {}; + + template <class R> + struct has_post_decrement<bool&, R> : public false_type {}; + template <> + struct has_post_decrement<bool&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_post_decrement<bool&, void> : public false_type {}; + +} + +#endif #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_post_increment.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_post_increment.hpp index 3861a2bbde2..e83afd1c312 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_post_increment.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_post_increment.hpp @@ -41,4 +41,25 @@ #undef BOOST_TT_TRAIT_OP #undef BOOST_TT_FORBIDDEN_IF +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template <class R> + struct has_post_increment<bool, R> : public false_type {}; + template <> + struct has_post_increment<bool, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_post_increment<bool, void> : public false_type {}; + + template <class R> + struct has_post_increment<bool&, R> : public false_type {}; + template <> + struct has_post_increment<bool&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_post_increment<bool&, void> : public false_type {}; + +} + +#endif #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_pre_decrement.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_pre_decrement.hpp index 7ef078329b2..5ce50e9003d 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_pre_decrement.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_pre_decrement.hpp @@ -41,4 +41,25 @@ #undef BOOST_TT_TRAIT_OP #undef BOOST_TT_FORBIDDEN_IF +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template <class R> + struct has_pre_decrement<bool, R> : public false_type {}; + template <> + struct has_pre_decrement<bool, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_pre_decrement<bool, void> : public false_type {}; + + template <class R> + struct has_pre_decrement<bool&, R> : public false_type {}; + template <> + struct has_pre_decrement<bool&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_pre_decrement<bool&, void> : public false_type {}; + +} + +#endif #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_pre_increment.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_pre_increment.hpp index c4c973487c8..9361cc8bee9 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_pre_increment.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_pre_increment.hpp @@ -41,4 +41,26 @@ #undef BOOST_TT_TRAIT_OP #undef BOOST_TT_FORBIDDEN_IF +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template <class R> + struct has_pre_increment<bool, R> : public false_type {}; + template <> + struct has_pre_increment<bool, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_pre_increment<bool, void> : public false_type {}; + + template <class R> + struct has_pre_increment<bool&, R> : public false_type {}; + template <> + struct has_pre_increment<bool&, boost::binary_op_detail::dont_care> : public false_type {}; + template <> + struct has_pre_increment<bool&, void> : public false_type {}; + +} + +#endif + #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_trivial_move_assign.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_trivial_move_assign.hpp index 6d954ab669d..7b392697f31 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_trivial_move_assign.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_trivial_move_assign.hpp @@ -24,7 +24,7 @@ #endif #endif -#if defined(__GNUC__) || defined(__clang) +#if defined(__GNUC__) || defined(__clang__) #include <boost/type_traits/is_assignable.hpp> #include <boost/type_traits/is_volatile.hpp> #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_trivial_move_constructor.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_trivial_move_constructor.hpp index 5784f4bbfff..ce85dc2d79c 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/has_trivial_move_constructor.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/has_trivial_move_constructor.hpp @@ -20,9 +20,10 @@ #if defined(BOOST_MSVC) || defined(BOOST_INTEL) #include <boost/type_traits/is_pod.hpp> #include <boost/type_traits/is_volatile.hpp> +#include <boost/type_traits/is_reference.hpp> #endif -#if defined(__GNUC__) || defined(__clang) +#if defined(__GNUC__) || defined(__clang__) #include <boost/type_traits/is_constructible.hpp> #include <boost/type_traits/is_volatile.hpp> #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/integral_constant.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/integral_constant.hpp index 164cb114914..2592bcb95db 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/integral_constant.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/integral_constant.hpp @@ -10,7 +10,7 @@ #include <boost/detail/workaround.hpp> #if (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ - || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) \ || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \ || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) )\ @@ -56,17 +56,12 @@ namespace boost{ typedef T value_type; typedef integral_constant<T, val> type; static const T value = val; - // - // This helper function is just to disable type-punning - // warnings from GCC: - // - template <class U> - static U& dereference(U* p) { return *p; } operator const mpl::integral_c<T, val>& ()const { static const char data[sizeof(long)] = { 0 }; - return dereference(reinterpret_cast<const mpl::integral_c<T, val>*>(&data)); + static const void* pdata = data; + return *(reinterpret_cast<const mpl::integral_c<T, val>*>(pdata)); } BOOST_CONSTEXPR operator T()const { return val; } }; @@ -81,17 +76,12 @@ namespace boost{ typedef bool value_type; typedef integral_constant<bool, val> type; static const bool value = val; - // - // This helper function is just to disable type-punning - // warnings from GCC: - // - template <class T> - static T& dereference(T* p) { return *p; } operator const mpl::bool_<val>& ()const { - static const char data = 0; - return dereference(reinterpret_cast<const mpl::bool_<val>*>(&data)); + static const char data[sizeof(long)] = { 0 }; + static const void* pdata = data; + return *(reinterpret_cast<const mpl::bool_<val>*>(pdata)); } BOOST_CONSTEXPR operator bool()const { return val; } }; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/integral_promotion.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/integral_promotion.hpp index 526f90ca993..cc6a41d0427 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/integral_promotion.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/integral_promotion.hpp @@ -38,7 +38,7 @@ template<> struct need_promotion<unsigned short int> : public true_type {}; // Same set of integral types as in boost/type_traits/is_integral.hpp. // Please, keep in sync. #if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ - || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) + || (defined(BOOST_BORLANDC) && (BOOST_BORLANDC == 0x600) && (_MSC_VER < 1300)) // TODO: common macro for this #if. Or better yet, PP SEQ of non-standard types. BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int8 ) BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int8 ) @@ -46,7 +46,7 @@ BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int16 ) BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int16) BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int32 ) BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int32) -#ifdef __BORLANDC__ +#ifdef BOOST_BORLANDC BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int64) BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE( __int64) #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/intrinsics.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/intrinsics.hpp index 7d97157a77d..72b6d90ef1f 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/intrinsics.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/intrinsics.hpp @@ -122,19 +122,25 @@ // This one fails if the default alignment has been changed with /Zp: // # define BOOST_ALIGNMENT_OF(T) __alignof(T) -# if defined(_MSC_VER) && (_MSC_VER >= 1700) +# if defined(_MSC_VER) && (_MSC_VER >= 1800) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__is_trivially_constructible(T, T&&) || boost::is_pod<T>::value) && ! ::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__is_trivially_assignable(T, T&&) || boost::is_pod<T>::value) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value) +# elif defined(_MSC_VER) && (_MSC_VER >= 1700) # define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || boost::is_pod<T>::value) && ! ::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value) # define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || boost::is_pod<T>::value) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value) # endif #ifndef BOOST_NO_CXX11_FINAL // This one doesn't quite always do the right thing on older VC++ versions -// we really need it when the final keyword is supporyted though: +// we really need it when the final keyword is supported though: # define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) #endif #if _MSC_FULL_VER >= 180020827 # define BOOST_IS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&)) # define BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) (__is_nothrow_constructible(T, T&&)) #endif +#if _MSC_VER >= 1800 +# define BOOST_IS_FINAL(T) __is_final(T) +#endif # define BOOST_HAS_TYPE_TRAITS_INTRINSICS #endif @@ -154,7 +160,7 @@ # define BOOST_HAS_TYPE_TRAITS_INTRINSICS #endif -#if defined(BOOST_CLANG) && defined(__has_feature) && !defined(__CUDACC__) +#if defined(BOOST_CLANG) && defined(__has_feature) && (!(defined(__CUDACC__) && (__CUDACC_VER_MAJOR__ < 11)) || defined(__CUDA__)) // // Note that these intrinsics are disabled for the CUDA meta-compiler as it appears // to not support them, even though the underlying clang compiler does so. @@ -219,12 +225,14 @@ # if __has_feature(is_polymorphic) # define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) # endif -# if __has_feature(has_trivial_move_constructor) -# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T) && is_constructible<T, T&&>::value && !::boost::is_volatile<T>::value) +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +# if __has_extension(is_trivially_constructible) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_trivially_constructible(T, T&&) && is_constructible<T, T&&>::value && !::boost::is_volatile<T>::value) # endif -# if __has_feature(has_trivial_move_assign) -# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) && is_assignable<T&, T&&>::value && !::boost::is_volatile<T>::value) +# if __has_extension(is_trivially_assignable) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_trivially_assignable(T&, T&&) && is_assignable<T&, T&&>::value && !::boost::is_volatile<T>::value) # endif +#endif # if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) || !defined(__GNUC__) // GCC sometimes lies about alignment requirements // of type double on 32-bit unix platforms, use the @@ -266,7 +274,9 @@ # define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value) # define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS) # define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS) +#if ((__GNUC__ * 100 + __GNUC_MINOR__) != 407) && ((__GNUC__ * 100 + __GNUC_MINOR__) != 408) # define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value && !is_array<T>::value) +#endif # define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value && !is_array<T>::value) #endif # define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) @@ -346,7 +356,7 @@ # define BOOST_HAS_TYPE_TRAITS_INTRINSICS #endif -# if defined(__CODEGEARC__) +# if defined(BOOST_CODEGEARC) # include <boost/type_traits/is_same.hpp> # include <boost/type_traits/is_reference.hpp> # include <boost/type_traits/is_volatile.hpp> diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_array.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_array.hpp index 53e1613ab6e..16f6a1b2276 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_array.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_array.hpp @@ -19,7 +19,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_array : public integral_constant<bool, __is_array(T)> {}; #else template <class T> struct is_array : public false_type {}; @@ -28,7 +28,7 @@ namespace boost { template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{}; template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{}; template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{}; -#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) template <class T> struct is_array<T[]> : public true_type{}; template <class T> struct is_array<T const[]> : public true_type{}; template <class T> struct is_array<T const volatile[]> : public true_type{}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_base_and_derived.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_base_and_derived.hpp index ee3dce597c1..7973e5af571 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_base_and_derived.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_base_and_derived.hpp @@ -26,7 +26,7 @@ namespace boost { namespace detail { #ifndef BOOST_IS_BASE_OF -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) \ +#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581)) \ && !BOOST_WORKAROUND(__SUNPRO_CC , <= 0x540) \ && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) \ && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) @@ -235,7 +235,7 @@ template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{}; template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{}; -#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610)) +#if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x610)) template <class Base> struct is_base_and_derived<Base, Base> : public true_type{}; #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_complete.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_complete.hpp index fe5e338c745..08f0e6277ab 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_complete.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_complete.hpp @@ -9,10 +9,13 @@ #ifndef BOOST_TT_IS_COMPLETE_HPP_INCLUDED #define BOOST_TT_IS_COMPLETE_HPP_INCLUDED +#include <boost/type_traits/declval.hpp> #include <boost/type_traits/integral_constant.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/type_traits/is_function.hpp> +#include <boost/type_traits/detail/yes_no_type.hpp> #include <boost/config/workaround.hpp> +#include <cstddef> /* * CAUTION: @@ -38,7 +41,7 @@ namespace boost { namespace detail{ - template <unsigned N> + template <std::size_t N> struct ok_tag { double d; char c[N]; }; template <class T> @@ -48,7 +51,7 @@ namespace boost { } template <class T> struct is_complete - : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(detail::check_is_complete<T>(0)) != sizeof(char))> {}; + : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(boost::detail::check_is_complete<T>(0)) != sizeof(char))> {}; #elif !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) @@ -58,7 +61,7 @@ namespace boost { template <class T> struct is_complete_imp { - template <class U, class = decltype(sizeof(std::declval< U >())) > + template <class U, class = decltype(sizeof(boost::declval< U >())) > static type_traits::yes_type check(U*); template <class U> diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_compound.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_compound.hpp index 7995eb8a237..08f6e1198ad 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_compound.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_compound.hpp @@ -13,7 +13,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_compound : public integral_constant<bool, __is_compound(T)> {}; #else template <class T> struct is_compound : public integral_constant<bool, ! ::boost::is_fundamental<T>::value> {}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_const.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_const.hpp index e0ed88a34b3..256326f803f 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_const.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_const.hpp @@ -26,7 +26,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_const : public integral_constant<bool, __is_const(T)> {}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_constructible.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_constructible.hpp index da6259948b9..6969cd63bea 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_constructible.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_constructible.hpp @@ -51,7 +51,7 @@ namespace boost{ { BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility"); }; - template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)> + template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(boost::detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)> { BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility"); }; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_convertible.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_convertible.hpp index bf648fc46ea..f873ef6bfd4 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_convertible.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_convertible.hpp @@ -96,7 +96,7 @@ namespace detail { static const bool value = sizeof(test<From, To>(0)) == 1; }; -#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560) +#elif defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x560) // // special version for Borland compilers // this version breaks when used for some @@ -120,7 +120,7 @@ struct is_convertible_impl #pragma option pop }; -#elif defined(__GNUC__) || defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +#elif defined(__GNUC__) || defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x600) // special version for gcc compiler + recent Borland versions // note that this does not pass UDT's through (...) @@ -358,7 +358,7 @@ struct is_convertible_impl value = ( ::boost::detail::is_convertible_basic_impl<From,To>::value && ! ::boost::is_array<To>::value && ! ::boost::is_function<To>::value) }; }; -#elif !defined(__BORLANDC__) || __BORLANDC__ > 0x551 +#elif !defined(BOOST_BORLANDC) || BOOST_BORLANDC > 0x551 template <typename From, typename To> struct is_convertible_impl { @@ -489,7 +489,7 @@ struct is_convertible : public integral_constant<bool, ::boost::detail::is_conve template <class From, class To> struct is_convertible : public integral_constant<bool, BOOST_IS_CONVERTIBLE(From, To)> { -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1900) +#if defined(BOOST_MSVC) BOOST_STATIC_ASSERT_MSG(boost::is_complete<From>::value || boost::is_void<From>::value || boost::is_array<From>::value || boost::is_reference<From>::value, "From argument type to is_convertible must be a complete type"); #endif #if defined(__clang__) diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_copy_assignable.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_copy_assignable.hpp index 76afdda5ddc..ed04927b603 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_copy_assignable.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_copy_assignable.hpp @@ -11,8 +11,7 @@ #include <boost/config.hpp> #include <boost/type_traits/detail/yes_no_type.hpp> -#include <boost/type_traits/is_base_and_derived.hpp> -#include <boost/noncopyable.hpp> +#include <boost/type_traits/is_noncopyable.hpp> #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \ && !defined(BOOST_INTEL_CXX_VERSION) && \ @@ -112,7 +111,7 @@ struct is_copy_assignable_impl { typedef BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type unreferenced_t; BOOST_STATIC_CONSTANT(bool, value = ( boost::detail::is_copy_assignable_impl2< - boost::is_base_and_derived<boost::noncopyable, T>::value + boost::is_noncopyable<T>::value || boost::is_const<unreferenced_t>::value || boost::is_array<unreferenced_t>::value ,T >::value @@ -120,7 +119,7 @@ struct is_copy_assignable_impl { #else BOOST_STATIC_CONSTANT(bool, value = ( boost::detail::is_copy_assignable_impl2< - boost::is_base_and_derived<boost::noncopyable, T>::value,T + boost::is_noncopyable<T>::value,T >::value )); #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_copy_constructible.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_copy_constructible.hpp index c68826431b0..ef97e18eb56 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_copy_constructible.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_copy_constructible.hpp @@ -37,8 +37,7 @@ template <> struct is_copy_constructible<void volatile> : public false_type{}; // an incorrect value, which just defers the issue into the users code) as well. We can at least fix // boost::non_copyable as a base class as a special case: // -#include <boost/type_traits/is_base_and_derived.hpp> -#include <boost/noncopyable.hpp> +#include <boost/type_traits/is_noncopyable.hpp> namespace boost { @@ -50,7 +49,7 @@ namespace boost { } - template <class T> struct is_copy_constructible : public detail::is_copy_constructible_imp<T, is_base_and_derived<boost::noncopyable, T>::value>{}; + template <class T> struct is_copy_constructible : public detail::is_copy_constructible_imp<T, is_noncopyable<T>::value>{}; template <> struct is_copy_constructible<void> : public false_type{}; template <> struct is_copy_constructible<void const> : public false_type{}; @@ -64,13 +63,12 @@ namespace boost { #else #include <boost/type_traits/detail/yes_no_type.hpp> -#include <boost/type_traits/is_base_and_derived.hpp> +#include <boost/type_traits/is_noncopyable.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/is_rvalue_reference.hpp> #include <boost/type_traits/declval.hpp> #include <boost/type_traits/is_array.hpp> #include <boost/type_traits/declval.hpp> -#include <boost/noncopyable.hpp> #ifdef BOOST_MSVC #pragma warning(push) @@ -160,7 +158,7 @@ namespace boost { BOOST_STATIC_CONSTANT(bool, value = ( boost::detail::is_copy_constructible_impl2< - boost::is_base_and_derived<boost::noncopyable, T>::value, + boost::is_noncopyable<T>::value, T >::value )); diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_default_constructible.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_default_constructible.hpp index 9a4a0a78b29..04c023fe68c 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_default_constructible.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_default_constructible.hpp @@ -58,7 +58,7 @@ namespace boost{ BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types"); }; #else - template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)> + template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(boost::detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)> { BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types"); }; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_destructible.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_destructible.hpp index cc72fb7a9a5..c32e758c6cf 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_destructible.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_destructible.hpp @@ -34,7 +34,7 @@ namespace boost{ } - template <class T> struct is_destructible : public integral_constant<bool, sizeof(detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)> + template <class T> struct is_destructible : public integral_constant<bool, sizeof(boost::detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)> { BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_destructible must be complete types"); }; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_empty.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_empty.hpp index ef288c518b1..ce623e35f42 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_empty.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_empty.hpp @@ -50,7 +50,7 @@ private: struct empty_helper_t2 { int i[256]; }; -#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) template <typename T, bool is_a_class = false> struct empty_helper @@ -75,7 +75,7 @@ struct is_empty_impl value = ( ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value || BOOST_INTERNAL_IS_EMPTY(cvt))); }; -#else // __BORLANDC__ +#else // BOOST_BORLANDC template <typename T, bool is_a_class, bool convertible_to_int> struct empty_helper @@ -103,10 +103,10 @@ struct is_empty_impl cvt , ::boost::is_class<T>::value , ::boost::is_convertible< r_type,int>::value - >::value || BOOST_INTERNAL_IS_EMPTY(cvt)); + >::value || BOOST_INTERNAL_IS_EMPTY(cvt))); }; -#endif // __BORLANDC__ +#endif // BOOST_BORLANDC } // namespace detail diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_enum.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_enum.hpp index eada480a658..d23baa1145b 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_enum.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_enum.hpp @@ -32,7 +32,7 @@ namespace boost { #ifndef BOOST_IS_ENUM -#if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)) +#if !(defined(BOOST_BORLANDC) && (BOOST_BORLANDC <= 0x551)) namespace detail { @@ -49,7 +49,7 @@ struct is_class_or_union template <typename T> struct is_class_or_union { -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way. +# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))// we simply can't detect it this way. BOOST_STATIC_CONSTANT(bool, value = false); # else template <class U> static ::boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void)); @@ -131,7 +131,7 @@ template <typename T> struct is_enum_impl #endif -#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) +#if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) typedef ::boost::detail::is_enum_helper< ::boost::detail::is_enum_impl<T>::selector > se_t; @@ -147,7 +147,7 @@ template <typename T> struct is_enum_impl template <class T> struct is_enum : public integral_constant<bool, ::boost::detail::is_enum_impl<T>::value> {}; -#else // __BORLANDC__ +#else // BOOST_BORLANDC // // buggy is_convertible prevents working // implementation of is_enum: diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_final.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_final.hpp index 410d18663b8..21ac93f3410 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_final.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_final.hpp @@ -20,7 +20,7 @@ namespace boost { #ifdef BOOST_IS_FINAL -template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(typename remove_cv<T>::type)> {}; +template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(T)> {}; #else template <class T> struct is_final : public integral_constant<bool, false> {}; #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_function.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_function.hpp index f77c1f0469d..1518f7b8e1e 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_function.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_function.hpp @@ -11,92 +11,17 @@ #ifndef BOOST_TT_IS_FUNCTION_HPP_INCLUDED #define BOOST_TT_IS_FUNCTION_HPP_INCLUDED -#include <boost/type_traits/is_reference.hpp> #include <boost/type_traits/detail/config.hpp> +#include <boost/config/workaround.hpp> -#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS) -# include <boost/type_traits/detail/is_function_ptr_helper.hpp> -#else -# include <boost/type_traits/detail/is_function_ptr_tester.hpp> -# include <boost/type_traits/detail/yes_no_type.hpp> -#endif - -// is a type a function? -// Please note that this implementation is unnecessarily complex: -// we could just use !is_convertible<T*, const volatile void*>::value, -// except that some compilers erroneously allow conversions from -// function pointers to void*. - -namespace boost { - -#if !defined( __CODEGEARC__ ) +#ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION -namespace detail { - -#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS) -template<bool is_ref = true> -struct is_function_chooser -{ - template< typename T > struct result_ - : public false_type {}; -}; - -template <> -struct is_function_chooser<false> -{ - template< typename T > struct result_ - : public ::boost::type_traits::is_function_ptr_helper<T*> {}; -}; - -template <typename T> -struct is_function_impl - : public is_function_chooser< ::boost::is_reference<T>::value > - ::BOOST_NESTED_TEMPLATE result_<T> -{ -}; +#include <boost/type_traits/detail/is_function_cxx_11.hpp> #else -template <typename T> -struct is_function_impl -{ -#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) -#pragma warning(push) -#pragma warning(disable:6334) -#endif - static T* t; - BOOST_STATIC_CONSTANT( - bool, value = sizeof(::boost::type_traits::is_function_ptr_tester(t)) - == sizeof(::boost::type_traits::yes_type) - ); -#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) -#pragma warning(pop) -#endif -}; - -template <typename T> -struct is_function_impl<T&> : public false_type -{}; -#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES -template <typename T> -struct is_function_impl<T&&> : public false_type -{}; -#endif - -#endif +#include <boost/type_traits/detail/is_function_cxx_03.hpp> -} // namespace detail - -#endif // !defined( __CODEGEARC__ ) - -#if defined( __CODEGEARC__ ) -template <class T> struct is_function : integral_constant<bool, __is_function(T)> {}; -#else -template <class T> struct is_function : integral_constant<bool, ::boost::detail::is_function_impl<T>::value> {}; -#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES -template <class T> struct is_function<T&&> : public false_type {}; -#endif #endif -} // namespace boost #endif // BOOST_TT_IS_FUNCTION_HPP_INCLUDED diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_fundamental.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_fundamental.hpp index f58767a4890..5ce28d49e05 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_fundamental.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_fundamental.hpp @@ -15,7 +15,7 @@ namespace boost { //* is a type T a fundamental type described in the standard (3.9.1) -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_fundamental : public integral_constant<bool, __is_fundamental(T)> {}; #else template <class T> struct is_fundamental : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_void<T>::value> {}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_integral.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_integral.hpp index 7a7e54bb701..6c6e239c31f 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_integral.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_integral.hpp @@ -14,7 +14,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_integral : public integral_constant<bool, __is_integral(T)> {}; #else @@ -50,14 +50,14 @@ template<> struct is_integral<wchar_t> : public true_type{}; // Same set of integral types as in boost/type_traits/integral_promotion.hpp. // Please, keep in sync. -- Alexander Nasonov #if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ - || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) + || (defined(BOOST_BORLANDC) && (BOOST_BORLANDC == 0x600) && (_MSC_VER < 1300)) template<> struct is_integral<unsigned __int8> : public true_type{}; template<> struct is_integral<unsigned __int16> : public true_type{}; template<> struct is_integral<unsigned __int32> : public true_type{}; template<> struct is_integral<__int8> : public true_type{}; template<> struct is_integral<__int16> : public true_type{}; template<> struct is_integral<__int32> : public true_type{}; -#ifdef __BORLANDC__ +#ifdef BOOST_BORLANDC template<> struct is_integral<unsigned __int64> : public true_type{}; template<> struct is_integral<__int64> : public true_type{}; #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_lvalue_reference.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_lvalue_reference.hpp index e94d7874817..553cb9f4e7f 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_lvalue_reference.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_lvalue_reference.hpp @@ -25,7 +25,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_lvalue_reference : public integral_constant<bool, __is_reference(T)>{}; #else diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_member_function_pointer.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_member_function_pointer.hpp index 223197f333e..dccd440a5f0 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_member_function_pointer.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_member_function_pointer.hpp @@ -12,109 +12,15 @@ #define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED #include <boost/type_traits/detail/config.hpp> -#include <boost/detail/workaround.hpp> -#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) - // - // Note: we use the "workaround" version for MSVC because it works for - // __stdcall etc function types, where as the partial specialisation - // version does not do so. - // -# include <boost/type_traits/detail/is_mem_fun_pointer_impl.hpp> -# include <boost/type_traits/remove_cv.hpp> -# include <boost/type_traits/integral_constant.hpp> -#else -# include <boost/type_traits/is_reference.hpp> -# include <boost/type_traits/is_array.hpp> -# include <boost/type_traits/detail/yes_no_type.hpp> -# include <boost/type_traits/detail/is_mem_fun_pointer_tester.hpp> -#endif - -namespace boost { +#ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION -#if defined( __CODEGEARC__ ) -template <class T> struct is_member_function_pointer : public integral_constant<bool, __is_member_function_pointer( T )> {}; -#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) - -template <class T> struct is_member_function_pointer - : public ::boost::integral_constant<bool, ::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value>{}; +#include <boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp> #else -namespace detail { - -#ifndef __BORLANDC__ - -template <bool> -struct is_mem_fun_pointer_select -{ - template <class T> struct result_ : public false_type{}; -}; - -template <> -struct is_mem_fun_pointer_select<false> -{ - template <typename T> struct result_ - { -#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) -#pragma warning(push) -#pragma warning(disable:6334) -#endif - static T* make_t; - typedef result_<T> self_type; - - BOOST_STATIC_CONSTANT( - bool, value = ( - 1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(self_type::make_t)) - )); -#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) -#pragma warning(pop) -#endif - }; -}; - -template <typename T> -struct is_member_function_pointer_impl - : public is_mem_fun_pointer_select< - ::boost::is_reference<T>::value || ::boost::is_array<T>::value>::template result_<T>{}; +#include <boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp> -template <typename T> -struct is_member_function_pointer_impl<T&> : public false_type{}; - -#else // Borland C++ - -template <typename T> -struct is_member_function_pointer_impl -{ - static T* m_t; - BOOST_STATIC_CONSTANT( - bool, value = - (1 == sizeof(type_traits::is_mem_fun_pointer_tester(m_t))) ); -}; - -template <typename T> -struct is_member_function_pointer_impl<T&> -{ - BOOST_STATIC_CONSTANT(bool, value = false); -}; - -#endif - -template<> struct is_member_function_pointer_impl<void> : public false_type{}; -#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS -template<> struct is_member_function_pointer_impl<void const> : public false_type{}; -template<> struct is_member_function_pointer_impl<void const volatile> : public false_type{}; -template<> struct is_member_function_pointer_impl<void volatile> : public false_type{}; #endif -} // namespace detail - -template <class T> -struct is_member_function_pointer - : public integral_constant<bool, ::boost::detail::is_member_function_pointer_impl<T>::value>{}; - -#endif - -} // namespace boost - #endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_member_pointer.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_member_pointer.hpp index 9757afc950a..2078f15b86e 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_member_pointer.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_member_pointer.hpp @@ -26,7 +26,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_member_pointer : public integral_constant<bool, __is_member_pointer(T)>{}; #else template <class T> struct is_member_pointer : public integral_constant<bool, ::boost::is_member_function_pointer<T>::value>{}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_noncopyable.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_noncopyable.hpp new file mode 100644 index 00000000000..787103ea710 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_noncopyable.hpp @@ -0,0 +1,39 @@ +#ifndef BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED + +// +// Copyright 2018 Peter Dimov +// +// 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 +// +// is_noncopyable<T> returns whether T is derived from boost::noncopyable +// + +#include <boost/type_traits/is_base_and_derived.hpp> + +namespace boost +{ + +#ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED +#define BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED + +// boost::noncopyable derives from noncopyable_::base_token to enable us +// to recognize it. The definition is macro-guarded so that we can replicate +// it here without including boost/core/noncopyable.hpp, which is in Core. + +namespace noncopyable_ +{ + struct base_token {}; +} + +#endif // #ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED + +template<class T> struct is_noncopyable: is_base_and_derived<noncopyable_::base_token, T> +{ +}; + +} // namespace boost + +#endif // #ifndef BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_nothrow_move_assignable.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_nothrow_move_assignable.hpp index 5f63cb7be6b..c6194de8e81 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_nothrow_move_assignable.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_nothrow_move_assignable.hpp @@ -16,7 +16,7 @@ #include <boost/type_traits/has_nothrow_assign.hpp> #include <boost/type_traits/is_array.hpp> #include <boost/type_traits/is_reference.hpp> -#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/enable_if.hpp> #include <boost/type_traits/declval.hpp> #include <boost/type_traits/is_complete.hpp> #include <boost/static_assert.hpp> @@ -48,7 +48,7 @@ struct false_or_cpp11_noexcept_move_assignable: public ::boost::false_type {}; template <class T> struct false_or_cpp11_noexcept_move_assignable < T, - typename ::boost::enable_if_c<sizeof(T) && BOOST_NOEXCEPT_EXPR(::boost::declval<T&>() = ::boost::declval<T>())>::type + typename ::boost::enable_if_<sizeof(T) && BOOST_NOEXCEPT_EXPR(::boost::declval<T&>() = ::boost::declval<T>())>::type > : public ::boost::integral_constant<bool, BOOST_NOEXCEPT_EXPR(::boost::declval<T&>() = ::boost::declval<T>())> {}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_nothrow_move_constructible.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_nothrow_move_constructible.hpp index 30b6a16ec84..60c2994d054 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_nothrow_move_constructible.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_nothrow_move_constructible.hpp @@ -35,7 +35,7 @@ template <class T> struct is_nothrow_move_constructible<const volatile T> : publ #elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) #include <boost/type_traits/declval.hpp> -#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/enable_if.hpp> namespace boost{ namespace detail{ @@ -45,7 +45,7 @@ struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {} template <class T> struct false_or_cpp11_noexcept_move_constructible < T, - typename ::boost::enable_if_c<sizeof(T) && BOOST_NOEXCEPT_EXPR(T(::boost::declval<T>()))>::type + typename ::boost::enable_if_<sizeof(T) && BOOST_NOEXCEPT_EXPR(T(::boost::declval<T>()))>::type > : public ::boost::integral_constant<bool, BOOST_NOEXCEPT_EXPR(T(::boost::declval<T>()))> {}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_pointer.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_pointer.hpp index 44b06c227ed..632c3c88830 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_pointer.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_pointer.hpp @@ -25,7 +25,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_pointer : public integral_constant<bool, __is_pointer(T)>{}; #else template <class T> struct is_pointer : public false_type{}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_rvalue_reference.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_rvalue_reference.hpp index a48edb5140e..37d33c95a40 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_rvalue_reference.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_rvalue_reference.hpp @@ -21,5 +21,9 @@ template <class T> struct is_rvalue_reference<T&&> : public true_type {}; } // namespace boost +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1700) +#include <boost/type_traits/detail/is_rvalue_reference_msvc10_fix.hpp> +#endif + #endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_same.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_same.hpp index d16f4b2b1a3..9a9ec7e6329 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_same.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_same.hpp @@ -28,7 +28,7 @@ namespace boost { template <class T, class U> struct is_same : public false_type {}; template <class T> struct is_same<T,T> : public true_type {}; -#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) +#if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) // without this, Borland's compiler gives the wrong answer for // references to arrays: template <class T> struct is_same<T&, T&> : public true_type{}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_scoped_enum.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_scoped_enum.hpp new file mode 100644 index 00000000000..7566859fbc1 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_scoped_enum.hpp @@ -0,0 +1,26 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ + +#ifndef BOOST_TT_IS_SCOPED_ENUM_HPP_INCLUDED +#define BOOST_TT_IS_SCOPED_ENUM_HPP_INCLUDED + +#include <boost/type_traits/conjunction.hpp> +#include <boost/type_traits/is_enum.hpp> +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/negation.hpp> + +namespace boost { + +template<class T> +struct is_scoped_enum + : conjunction<is_enum<T>, negation<is_convertible<T, int> > >::type { }; + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_signed.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_signed.hpp index 70ca2e47967..4d50bf8c6fd 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_signed.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_signed.hpp @@ -17,7 +17,7 @@ namespace boost { -#if !defined( __CODEGEARC__ ) +#if !defined( BOOST_CODEGEARC ) #if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1310) && \ !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) &&\ @@ -84,7 +84,7 @@ template <class T> struct is_signed : public false_type{}; #endif -#else //defined( __CODEGEARC__ ) +#else //defined( BOOST_CODEGEARC ) template <class T> struct is_signed : public integral_constant<bool, __is_signed(T)>{}; #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_trivially_copyable.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_trivially_copyable.hpp new file mode 100644 index 00000000000..a62668aaef9 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_trivially_copyable.hpp @@ -0,0 +1,31 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ + +#ifndef BOOST_TT_IS_TRIVIALLY_COPYABLE_HPP_INCLUDED +#define BOOST_TT_IS_TRIVIALLY_COPYABLE_HPP_INCLUDED + +#include <boost/type_traits/has_trivial_assign.hpp> +#include <boost/type_traits/has_trivial_copy.hpp> +#include <boost/type_traits/has_trivial_destructor.hpp> +#include <boost/type_traits/has_trivial_move_assign.hpp> +#include <boost/type_traits/has_trivial_move_constructor.hpp> + +namespace boost { + +template<class T> +struct is_trivially_copyable + : integral_constant<bool, has_trivial_copy<T>::value && + has_trivial_assign<T>::value && + has_trivial_move_constructor<T>::value && + has_trivial_move_assign<T>::value && + has_trivial_destructor<T>::value> { }; + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_unscoped_enum.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_unscoped_enum.hpp new file mode 100644 index 00000000000..99f9acb9762 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_unscoped_enum.hpp @@ -0,0 +1,25 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ + +#ifndef BOOST_TT_IS_UNSCOPED_ENUM_HPP_INCLUDED +#define BOOST_TT_IS_UNSCOPED_ENUM_HPP_INCLUDED + +#include <boost/type_traits/conjunction.hpp> +#include <boost/type_traits/is_enum.hpp> +#include <boost/type_traits/is_convertible.hpp> + +namespace boost { + +template<class T> +struct is_unscoped_enum + : conjunction<is_enum<T>, is_convertible<T, int> >::type { }; + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_unsigned.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_unsigned.hpp index c4c54af7b36..38b916296df 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_unsigned.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_unsigned.hpp @@ -18,7 +18,7 @@ namespace boost { -#if !defined( __CODEGEARC__ ) +#if !defined( BOOST_CODEGEARC ) #if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1310) &&\ !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) &&\ @@ -84,7 +84,7 @@ template <class T> struct is_unsigned : public false_type{}; #endif -#else // defined( __CODEGEARC__ ) +#else // defined( BOOST_CODEGEARC ) template <class T> struct is_unsigned : public integral_constant<bool, __is_unsigned(T)> {}; #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_virtual_base_of.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_virtual_base_of.hpp index 84cb355cd0a..c665078bd3a 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_virtual_base_of.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_virtual_base_of.hpp @@ -1,4 +1,5 @@ // (C) Copyright Daniel Frey and Robert Ramey 2009. +// (C) Copyright Balint Cserni 2017 // Use, modification and distribution are subject to 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). @@ -10,9 +11,11 @@ #include <boost/type_traits/is_base_of.hpp> #include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/make_void.hpp> +#include <utility> namespace boost { -namespace detail { + namespace detail { #ifdef BOOST_MSVC @@ -22,84 +25,122 @@ namespace detail { #pragma GCC system_header #endif -template<typename Base, typename Derived, typename tag> -struct is_virtual_base_of_impl -{ - BOOST_STATIC_CONSTANT(bool, value = false); -}; +#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_CXX11_NULLPTR) && !BOOST_WORKAROUND(BOOST_GCC, < 40800) -template<typename Base, typename Derived> -struct is_virtual_base_of_impl<Base, Derived, true_type> -{ - union max_align + // Implementation based on the standard's rules of explicit type conversions. + // A pointer to an object of *derived* class type may be explicitly converted to a pointer to an *unambiguous* *base* class type. + // A pointer to an object of an *unambiguous* *non-virtual* *base* class type may be explicitly converted to a pointer of a *derived* class type. + // Therefore Derived has a virtual base Base if and only if + // (1) a Derived* can be converted to Base* (so the base class is unambiguous, which comes necessarily from virtual inheritance) + // (2) a Base* cannot be converted to Derived* (so the base class is either ambiguous or virtual) + // With both conditions true, Base must be a virtual base of Derived. + // The "is_base_of" is only needed so the compiler can (but is not required to) error out if the types are incomplete. + // This is in league with the the expected behaviour. + + template<class T, class U> + constexpr bool is_virtual_base_impl(...) { return true; } + + // C-style casts have the power to ignore inheritance visibility while still act as a static_cast. + // They can also fall back to the behaviour of reinterpret_cast, which allows is_virtual_base_of to work on non-class types too. + // Note that because we are casting pointers there can be no user-defined operators to interfere. + template<class T, class U, + typename boost::make_void<decltype((U*)(std::declval<T*>()))>::type* = + nullptr> + constexpr bool is_virtual_base_impl(int) { return false; } + + } // namespace detail + + template<class T, class U> + struct is_virtual_base_of : public + boost::integral_constant< + bool, + boost::is_base_of<T, U>::value && + detail::is_virtual_base_impl<T, U>(0) && + !detail::is_virtual_base_impl<U, T>(0) + > {}; + +#else + + template<typename Base, typename Derived, typename tag> + struct is_virtual_base_of_impl + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; + + template<typename Base, typename Derived> + struct is_virtual_base_of_impl<Base, Derived, true_type> { - unsigned u; - unsigned long ul; - void* v; - double d; - long double ld; + union max_align + { + unsigned u; + unsigned long ul; + void* v; + double d; + long double ld; #ifndef BOOST_NO_LONG_LONG - long long ll; + long long ll; #endif - }; -#ifdef __BORLANDC__ - struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base - { - boost_type_traits_internal_struct_X(); - boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&); - boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&); - ~boost_type_traits_internal_struct_X()throw(); - max_align data[4]; - }; - struct boost_type_traits_internal_struct_Y : public virtual Derived - { - boost_type_traits_internal_struct_Y(); - boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&); - boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&); - ~boost_type_traits_internal_struct_Y()throw(); - max_align data[4]; - }; + }; +#ifdef BOOST_BORLANDC + struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base + { + boost_type_traits_internal_struct_X(); + boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&); + boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&); + ~boost_type_traits_internal_struct_X()throw(); + max_align data[4]; + }; + struct boost_type_traits_internal_struct_Y : public virtual Derived + { + boost_type_traits_internal_struct_Y(); + boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&); + boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&); + ~boost_type_traits_internal_struct_Y()throw(); + max_align data[4]; + }; #else - struct boost_type_traits_internal_struct_X : public Derived, virtual Base - { - boost_type_traits_internal_struct_X(); - boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&); - boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&); - ~boost_type_traits_internal_struct_X()throw(); - max_align data[16]; - }; - struct boost_type_traits_internal_struct_Y : public Derived - { - boost_type_traits_internal_struct_Y(); - boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&); - boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&); - ~boost_type_traits_internal_struct_Y()throw(); - max_align data[16]; - }; + struct boost_type_traits_internal_struct_X : public Derived, virtual Base + { + boost_type_traits_internal_struct_X(); + boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&); + boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&); + ~boost_type_traits_internal_struct_X()throw(); + max_align data[16]; + }; + struct boost_type_traits_internal_struct_Y : public Derived + { + boost_type_traits_internal_struct_Y(); + boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&); + boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&); + ~boost_type_traits_internal_struct_Y()throw(); + max_align data[16]; + }; #endif - BOOST_STATIC_CONSTANT(bool, value = (sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y))); -}; - -template<typename Base, typename Derived> -struct is_virtual_base_of_impl2 -{ - typedef boost::integral_constant<bool, (boost::is_base_of<Base, Derived>::value && ! boost::is_same<Base, Derived>::value)> tag_type; - typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp; - BOOST_STATIC_CONSTANT(bool, value = imp::value); -}; + BOOST_STATIC_CONSTANT(bool, value = (sizeof(boost_type_traits_internal_struct_X) == sizeof(boost_type_traits_internal_struct_Y))); + }; -#ifdef BOOST_MSVC -#pragma warning( pop ) -#endif + template<typename Base, typename Derived> + struct is_virtual_base_of_impl2 + { + typedef boost::integral_constant<bool, (boost::is_base_of<Base, Derived>::value && !boost::is_same<Base, Derived>::value)> tag_type; + typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp; + BOOST_STATIC_CONSTANT(bool, value = imp::value); + }; } // namespace detail -template <class Base, class Derived> struct is_virtual_base_of : public integral_constant<bool, (::boost::detail::is_virtual_base_of_impl2<Base, Derived>::value)>{}; +template <class Base, class Derived> struct is_virtual_base_of : public integral_constant<bool, (::boost::detail::is_virtual_base_of_impl2<Base, Derived>::value)> {}; + +#endif template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived> : public false_type{}; template <class Base, class Derived> struct is_virtual_base_of<Base, Derived&> : public false_type{}; template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived&> : public false_type{}; +#ifdef BOOST_MSVC +#pragma warning( pop ) +#endif + } // namespace boost #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_volatile.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_volatile.hpp index 5b8e716b473..3f9b0630a75 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/is_volatile.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/is_volatile.hpp @@ -26,7 +26,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct is_volatile : public integral_constant<bool, __is_volatile(T)> {}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/make_void.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/make_void.hpp index f48823b0595..b8a72ef5716 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/make_void.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/make_void.hpp @@ -1,6 +1,6 @@ /* Copyright 2017 Glen Joseph Fernandes -<glenjofe -at- gmail.com> +(glenjofe@gmail.com) Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/negation.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/negation.hpp new file mode 100644 index 00000000000..939e7a77864 --- /dev/null +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/negation.hpp @@ -0,0 +1,23 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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) +*/ + +#ifndef BOOST_TT_NEGATION_HPP_INCLUDED +#define BOOST_TT_NEGATION_HPP_INCLUDED + +#include <boost/type_traits/integral_constant.hpp> + +namespace boost { + +template<class T> +struct negation + : integral_constant<bool, !bool(T::value)> { }; + +} /* boost */ + +#endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/rank.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/rank.hpp index 1f820f1a55d..db06cbd19ef 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/rank.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/rank.hpp @@ -15,7 +15,7 @@ namespace boost { -#if !defined( __CODEGEARC__ ) +#if !defined( BOOST_CODEGEARC ) namespace detail{ @@ -49,7 +49,7 @@ struct rank_imp<T const volatile[R], N> BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::rank_imp<T, N+1>::value)); }; -#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) template <class T, std::size_t N> struct rank_imp<T[], N> { @@ -74,9 +74,9 @@ struct rank_imp<T const volatile[], N> #endif } -#endif // !defined( __CODEGEARC__ ) +#endif // !defined( BOOST_CODEGEARC ) -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template <class T> struct rank : public integral_constant<std::size_t, __array_rank(T)>{}; #else template <class T> struct rank : public integral_constant<std::size_t, (::boost::detail::rank_imp<T, 0>::value)>{}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_all_extents.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_all_extents.hpp index b9736db57e7..4da725a33a6 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_all_extents.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_all_extents.hpp @@ -22,7 +22,7 @@ template <class T, std::size_t N> struct remove_all_extents<T[N]> : public remov template <class T, std::size_t N> struct remove_all_extents<T const[N]> : public remove_all_extents<T const>{}; template <class T, std::size_t N> struct remove_all_extents<T volatile[N]> : public remove_all_extents<T volatile>{}; template <class T, std::size_t N> struct remove_all_extents<T const volatile[N]> : public remove_all_extents<T const volatile>{}; -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) template <class T> struct remove_all_extents<T[]> : public remove_all_extents<T>{}; template <class T> struct remove_all_extents<T const[]> : public remove_all_extents<T const>{}; template <class T> struct remove_all_extents<T volatile[]> : public remove_all_extents<T volatile>{}; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_const.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_const.hpp index 6f1a193740b..045c6b8228f 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_const.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_const.hpp @@ -23,7 +23,7 @@ namespace boost { #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) template <class T, std::size_t N> struct remove_const<T const[N]>{ typedef T type[N]; }; -#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) template <class T> struct remove_const<T const[]>{ typedef T type[]; }; #endif #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_cv.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_cv.hpp index 57a96f29d63..2a68af533e0 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_cv.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_cv.hpp @@ -27,7 +27,7 @@ template <class T> struct remove_cv<T const volatile>{ typedef T type; }; template <class T, std::size_t N> struct remove_cv<T const[N]>{ typedef T type[N]; }; template <class T, std::size_t N> struct remove_cv<T const volatile[N]>{ typedef T type[N]; }; template <class T, std::size_t N> struct remove_cv<T volatile[N]>{ typedef T type[N]; }; -#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) template <class T> struct remove_cv<T const[]>{ typedef T type[]; }; template <class T> struct remove_cv<T const volatile[]>{ typedef T type[]; }; template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; }; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_extent.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_extent.hpp index 55d57301b70..866f4bce076 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_extent.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_extent.hpp @@ -22,7 +22,7 @@ template <typename T, std::size_t N> struct remove_extent<T[N]> { typedef T type template <typename T, std::size_t N> struct remove_extent<T const[N]> { typedef T const type; }; template <typename T, std::size_t N> struct remove_extent<T volatile [N]> { typedef T volatile type; }; template <typename T, std::size_t N> struct remove_extent<T const volatile [N]> { typedef T const volatile type; }; -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) template <typename T> struct remove_extent<T[]> { typedef T type; }; template <typename T> struct remove_extent<T const[]> { typedef T const type; }; template <typename T> struct remove_extent<T volatile[]> { typedef T volatile type; }; diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_volatile.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_volatile.hpp index bf2c55796a1..162d0c2a7fc 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_volatile.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/remove_volatile.hpp @@ -23,7 +23,7 @@ namespace boost { #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) template <class T, std::size_t N> struct remove_volatile<T volatile[N]>{ typedef T type[N]; }; -#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) template <class T> struct remove_volatile<T volatile[]>{ typedef T type[]; }; #endif #endif diff --git a/contrib/restricted/boost/type_traits/include/boost/type_traits/type_with_alignment.hpp b/contrib/restricted/boost/type_traits/include/boost/type_traits/type_with_alignment.hpp index 591f213b464..04489e311e4 100644 --- a/contrib/restricted/boost/type_traits/include/boost/type_traits/type_with_alignment.hpp +++ b/contrib/restricted/boost/type_traits/include/boost/type_traits/type_with_alignment.hpp @@ -25,7 +25,7 @@ #endif namespace boost { -#ifndef __BORLANDC__ +#ifndef BOOST_BORLANDC namespace detail{ union max_align @@ -120,7 +120,7 @@ template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{}; // registers. Therefore we extend type_with_alignment<> to support // such types, however, we have to be careful to use a builtin type // whenever possible otherwise we break previously working code: -// see http://article.gmane.org/gmane.comp.lib.boost.devel/173011 +// see https://lists.boost.org/Archives/boost/2014/03/212391.php // for an example and test case. Thus types like a8 below will // be used *only* if the existing implementation can't provide a type // with suitable alignment. This does mean however, that type_with_alignment<> @@ -227,7 +227,7 @@ namespace detail { typedef ::boost::tt_align_ns::a16 max_align; } -//#if ! BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610)) +//#if ! BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x610)) template <> struct is_pod< ::boost::tt_align_ns::a2> : public true_type{}; template <> struct is_pod< ::boost::tt_align_ns::a4> : public true_type{}; template <> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{}; |