#ifndef BOOST_ANY_INCLUDED
#define BOOST_ANY_INCLUDED
-#if defined(_MSC_VER)
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
// what: variant type boost::any
// who: contributed by Kevlin Henney,
// with features contributed and bugs found by
-// Antony Polukhin, Ed Brey, Mark Rodgers,
+// Antony Polukhin, Ed Brey, Mark Rodgers,
// Peter Dimov, and James Curran
-// when: July 2001, April 2013 - 2019
-
-#include <algorithm>
+// when: July 2001, April 2013 - 2020
-#include <boost/config.hpp>
+#include <boost/any/bad_any_cast.hpp>
+#include <boost/any/fwd.hpp>
#include <boost/type_index.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/decay.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/core/addressof.hpp>
#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/conditional.hpp>
namespace boost
BOOST_DEDUCED_TYPENAME remove_cv<BOOST_DEDUCED_TYPENAME decay<const ValueType>::type>::type
>(value))
{
+ BOOST_STATIC_ASSERT_MSG(
+ !anys::detail::is_basic_any<ValueType>::value,
+ "boost::any shall not be constructed from boost::anys::basic_any"
+ );
}
any(const any & other)
, typename boost::disable_if<boost::is_const<ValueType> >::type* = 0) // disable if value has type `const ValueType&&`
: content(new holder< typename decay<ValueType>::type >(static_cast<ValueType&&>(value)))
{
+ BOOST_STATIC_ASSERT_MSG(
+ !anys::detail::is_basic_any<typename boost::decay<ValueType>::type>::value,
+ "boost::any shall not be constructed from boost::anys::basic_any"
+ );
}
#endif
any & swap(any & rhs) BOOST_NOEXCEPT
{
- std::swap(content, rhs.content);
+ placeholder* tmp = content;
+ content = rhs.content;
+ rhs.content = tmp;
return *this;
}
template<typename ValueType>
any & operator=(const ValueType & rhs)
{
+ BOOST_STATIC_ASSERT_MSG(
+ !anys::detail::is_basic_any<ValueType>::value,
+ "boost::anys::basic_any shall not be assigned into boost::any"
+ );
any(rhs).swap(*this);
return *this;
}
return *this;
}
-#else
+#else
any & operator=(const any& rhs)
{
any(rhs).swap(*this);
template <class ValueType>
any & operator=(ValueType&& rhs)
{
+ BOOST_STATIC_ASSERT_MSG(
+ !anys::detail::is_basic_any<typename boost::decay<ValueType>::type>::value,
+ "boost::anys::basic_any shall not be assigned into boost::any"
+ );
any(static_cast<ValueType&&>(rhs)).swap(*this);
return *this;
}
#endif
public: // queries
- virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT
+ const boost::typeindex::type_info& type() const BOOST_NOEXCEPT BOOST_OVERRIDE
{
return boost::typeindex::type_id<ValueType>().type_info();
}
- virtual placeholder * clone() const
+ placeholder * clone() const BOOST_OVERRIDE
{
return new holder(held);
}
placeholder * content;
};
-
+
inline void swap(any & lhs, any & rhs) BOOST_NOEXCEPT
{
lhs.swap(rhs);
}
- class BOOST_SYMBOL_VISIBLE bad_any_cast :
-#ifndef BOOST_NO_RTTI
- public std::bad_cast
-#else
- public std::exception
-#endif
- {
- public:
- virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
- {
- return "boost::bad_any_cast: "
- "failed conversion using boost::any_cast";
- }
- };
-
template<typename ValueType>
ValueType * any_cast(any * operand) BOOST_NOEXCEPT
{
if(!result)
boost::throw_exception(bad_any_cast());
- // Attempt to avoid construction of a temporary object in cases when
+ // Attempt to avoid construction of a temporary object in cases when
// `ValueType` is not a reference. Example:
- // `static_cast<std::string>(*result);`
+ // `static_cast<std::string>(*result);`
// which is equal to `std::string(*result);`
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
boost::is_reference<ValueType>::value,
BOOST_STATIC_ASSERT_MSG(
boost::is_rvalue_reference<ValueType&&>::value /*true if ValueType is rvalue or just a value*/
|| boost::is_const< typename boost::remove_reference<ValueType>::type >::value,
- "boost::any_cast shall not be used for getting nonconst references to temporary objects"
+ "boost::any_cast shall not be used for getting nonconst references to temporary objects"
);
return any_cast<ValueType>(operand);
}
}
// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
-// Copyright Antony Polukhin, 2013-2019.
+// Copyright Antony Polukhin, 2013-2022.
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
--- /dev/null
+// Copyright Antony Polukhin, 2020-2022.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org/libs/any for Documentation.
+
+#ifndef BOOST_ANYS_BAD_ANY_CAST_HPP_INCLUDED
+#define BOOST_ANYS_BAD_ANY_CAST_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#ifndef BOOST_NO_RTTI
+#include <typeinfo>
+#endif
+
+#include <stdexcept>
+
+namespace boost {
+
+class BOOST_SYMBOL_VISIBLE bad_any_cast :
+#ifndef BOOST_NO_RTTI
+ public std::bad_cast
+#else
+ public std::exception
+#endif
+{
+public:
+ const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
+ {
+ return "boost::bad_any_cast: "
+ "failed conversion using boost::any_cast";
+ }
+};
+
+} // namespace boost
+
+
+#endif // #ifndef BOOST_ANYS_BAD_ANY_CAST_HPP_INCLUDED
--- /dev/null
+// Copyright Antony Polukhin, 2021-2022.
+//
+// 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)
+
+// Contributed by Ruslan Arutyunyan
+#ifndef BOOST_ANY_ANYS_FWD_HPP
+#define BOOST_ANY_ANYS_FWD_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+ #include <boost/type_traits/alignment_of.hpp>
+
+namespace boost {
+
+class any;
+
+namespace anys {
+
+template<std::size_t OptimizeForSize = sizeof(void*), std::size_t OptimizeForAlignment = boost::alignment_of<void*>::value>
+class basic_any;
+
+namespace detail {
+ template <class T>
+ struct is_basic_any: public false_type {};
+
+
+ template<std::size_t OptimizeForSize, std::size_t OptimizeForAlignment>
+ struct is_basic_any<boost::anys::basic_any<OptimizeForSize, OptimizeForAlignment> > : public true_type {};
+} // namespace detail
+
+} // namespace anys
+
+} // namespace boost
+
+#endif // #ifndef BOOST_ANY_ANYS_FWD_HPP
#endif
#include <cstddef>
+#include <iterator>
#include <stdexcept>
#include <boost/assert.hpp>
+#include <boost/core/swap.hpp>
#include <boost/static_assert.hpp>
-#include <boost/swap.hpp>
-// Handles broken standard libraries better than <iterator>
-#include <boost/detail/iterator.hpp>
#include <boost/throw_exception.hpp>
#include <algorithm>
--- /dev/null
+#ifndef BOOST_ASSERT_SOURCE_LOCATION_HPP_INCLUDED
+#define BOOST_ASSERT_SOURCE_LOCATION_HPP_INCLUDED
+
+// http://www.boost.org/libs/assert
+//
+// Copyright 2019, 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/current_function.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <boost/cstdint.hpp>
+#include <iosfwd>
+#include <string>
+#include <cstdio>
+#include <cstring>
+
+#if defined(__cpp_lib_source_location) && __cpp_lib_source_location >= 201907L
+# include <source_location>
+#endif
+
+namespace boost
+{
+
+struct source_location
+{
+private:
+
+ char const * file_;
+ char const * function_;
+ boost::uint_least32_t line_;
+ boost::uint_least32_t column_;
+
+public:
+
+ BOOST_CONSTEXPR source_location() BOOST_NOEXCEPT: file_( "" ), function_( "" ), line_( 0 ), column_( 0 )
+ {
+ }
+
+ BOOST_CONSTEXPR source_location( char const * file, boost::uint_least32_t ln, char const * function, boost::uint_least32_t col = 0 ) BOOST_NOEXCEPT: file_( file ), function_( function ), line_( ln ), column_( col )
+ {
+ }
+
+#if defined(__cpp_lib_source_location) && __cpp_lib_source_location >= 201907L
+
+ BOOST_CONSTEXPR source_location( std::source_location const& loc ) BOOST_NOEXCEPT: file_( loc.file_name() ), function_( loc.function_name() ), line_( loc.line() ), column_( loc.column() )
+ {
+ }
+
+#endif
+
+ BOOST_CONSTEXPR char const * file_name() const BOOST_NOEXCEPT
+ {
+ return file_;
+ }
+
+ BOOST_CONSTEXPR char const * function_name() const BOOST_NOEXCEPT
+ {
+ return function_;
+ }
+
+ BOOST_CONSTEXPR boost::uint_least32_t line() const BOOST_NOEXCEPT
+ {
+ return line_;
+ }
+
+ BOOST_CONSTEXPR boost::uint_least32_t column() const BOOST_NOEXCEPT
+ {
+ return column_;
+ }
+
+#if defined(BOOST_MSVC)
+# pragma warning( push )
+# pragma warning( disable: 4996 )
+#endif
+
+#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) )
+# define BOOST_ASSERT_SNPRINTF(buffer, format, arg) std::sprintf(buffer, format, arg)
+#else
+# define BOOST_ASSERT_SNPRINTF(buffer, format, arg) std::snprintf(buffer, sizeof(buffer)/sizeof(buffer[0]), format, arg)
+#endif
+
+ std::string to_string() const
+ {
+ unsigned long ln = line();
+
+ if( ln == 0 )
+ {
+ return "(unknown source location)";
+ }
+
+ std::string r = file_name();
+
+ char buffer[ 16 ];
+
+ BOOST_ASSERT_SNPRINTF( buffer, ":%lu", ln );
+ r += buffer;
+
+ unsigned long co = column();
+
+ if( co )
+ {
+ BOOST_ASSERT_SNPRINTF( buffer, ":%lu", co );
+ r += buffer;
+ }
+
+ char const* fn = function_name();
+
+ if( *fn != 0 )
+ {
+ r += " in function '";
+ r += fn;
+ r += '\'';
+ }
+
+ return r;
+ }
+
+#undef BOOST_ASSERT_SNPRINTF
+
+#if defined(BOOST_MSVC)
+# pragma warning( pop )
+#endif
+
+ inline friend bool operator==( source_location const& s1, source_location const& s2 ) BOOST_NOEXCEPT
+ {
+ return std::strcmp( s1.file_, s2.file_ ) == 0 && std::strcmp( s1.function_, s2.function_ ) == 0 && s1.line_ == s2.line_ && s1.column_ == s2.column_;
+ }
+
+ inline friend bool operator!=( source_location const& s1, source_location const& s2 ) BOOST_NOEXCEPT
+ {
+ return !( s1 == s2 );
+ }
+};
+
+template<class E, class T> std::basic_ostream<E, T> & operator<<( std::basic_ostream<E, T> & os, source_location const & loc )
+{
+ os << loc.to_string();
+ return os;
+}
+
+} // namespace boost
+
+#if defined(BOOST_DISABLE_CURRENT_LOCATION)
+
+# define BOOST_CURRENT_LOCATION ::boost::source_location()
+
+#elif defined(BOOST_MSVC) && BOOST_MSVC >= 1926
+
+// std::source_location::current() is available in -std:c++20, but fails with consteval errors before 19.31, and doesn't produce
+// the correct result under 19.31, so prefer the built-ins
+# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN())
+
+#elif defined(BOOST_MSVC)
+
+// __LINE__ is not a constant expression under /ZI (edit and continue) for 1925 and before
+
+# define BOOST_CURRENT_LOCATION_IMPL_1(x) BOOST_CURRENT_LOCATION_IMPL_2(x)
+# define BOOST_CURRENT_LOCATION_IMPL_2(x) (x##0 / 10)
+
+# define BOOST_CURRENT_LOCATION ::boost::source_location(__FILE__, BOOST_CURRENT_LOCATION_IMPL_1(__LINE__), "")
+
+#elif defined(__cpp_lib_source_location) && __cpp_lib_source_location >= 201907L
+
+# define BOOST_CURRENT_LOCATION ::boost::source_location(::std::source_location::current())
+
+#elif defined(BOOST_CLANG) && BOOST_CLANG_VERSION >= 90000
+
+# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN())
+
+#elif defined(BOOST_GCC) && BOOST_GCC >= 70000
+
+// The built-ins are available in 4.8+, but are not constant expressions until 7
+# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION())
+
+#elif defined(BOOST_GCC) && BOOST_GCC >= 50000
+
+// __PRETTY_FUNCTION__ is allowed outside functions under GCC, but 4.x suffers from codegen bugs
+# define BOOST_CURRENT_LOCATION ::boost::source_location(__FILE__, __LINE__, __PRETTY_FUNCTION__)
+
+#else
+
+// __func__ macros aren't allowed outside functions, but BOOST_CURRENT_LOCATION is
+# define BOOST_CURRENT_LOCATION ::boost::source_location(__FILE__, __LINE__, "")
+
+#endif
+
+#endif // #ifndef BOOST_ASSERT_SOURCE_LOCATION_HPP_INCLUDED
# include BOOST_ABI_PREFIX
#endif
-#if defined( __BORLANDC__ )
+#if defined( BOOST_BORLANDC )
#pragma nopushoptwarn
#endif
# include BOOST_ABI_SUFFIX
#endif
-#if defined( __BORLANDC__ )
+#if defined( BOOST_BORLANDC )
#pragma nopushoptwarn
#endif
-
-
--- /dev/null
+// This file was automatically generated on Sun Jun 5 16:50:18 2022
+// by libs/config/tools/generate.cpp
+// Copyright John Maddock 2002-21.
+// 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/config for the most recent version.//
+// Revision $Id$
+//
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_ADL_BARRIER
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_ADL_BARRIER."
+#endif
+#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP."
+#endif
+#ifdef BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS."
+#endif
+#ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_COMPLETE_VALUE_INITIALIZATION."
+#endif
+#ifdef BOOST_NO_CTYPE_FUNCTIONS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_CTYPE_FUNCTIONS."
+#endif
+#ifdef BOOST_NO_CV_SPECIALIZATIONS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_CV_SPECIALIZATIONS."
+#endif
+#ifdef BOOST_NO_CV_VOID_SPECIALIZATIONS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_CV_VOID_SPECIALIZATIONS."
+#endif
+#ifdef BOOST_NO_CWCHAR
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_CWCHAR."
+#endif
+#ifdef BOOST_NO_CWCTYPE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_CWCTYPE."
+#endif
+#ifdef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_DEPENDENT_NESTED_DERIVATIONS."
+#endif
+#ifdef BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS."
+#endif
+#ifdef BOOST_NO_EXCEPTIONS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_EXCEPTIONS."
+#endif
+#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_EXCEPTION_STD_NAMESPACE."
+#endif
+#ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS."
+#endif
+#ifdef BOOST_NO_FENV_H
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_FENV_H."
+#endif
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_FUNCTION_TEMPLATE_ORDERING."
+#endif
+#ifdef BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS."
+#endif
+#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_INCLASS_MEMBER_INITIALIZATION."
+#endif
+#ifdef BOOST_NO_INTEGRAL_INT64_T
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_INTEGRAL_INT64_T."
+#endif
+#ifdef BOOST_NO_INTRINSIC_WCHAR_T
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_INTRINSIC_WCHAR_T."
+#endif
+#ifdef BOOST_NO_IOSFWD
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_IOSFWD."
+#endif
+#ifdef BOOST_NO_IOSTREAM
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_IOSTREAM."
+#endif
+#ifdef BOOST_NO_IS_ABSTRACT
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_IS_ABSTRACT."
+#endif
+#ifdef BOOST_NO_LIMITS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_LIMITS."
+#endif
+#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS."
+#endif
+#ifdef BOOST_NO_LONG_LONG
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_LONG_LONG."
+#endif
+#ifdef BOOST_NO_LONG_LONG_NUMERIC_LIMITS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_LONG_LONG_NUMERIC_LIMITS."
+#endif
+#ifdef BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS."
+#endif
+#ifdef BOOST_NO_MEMBER_TEMPLATES
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_MEMBER_TEMPLATES."
+#endif
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_MEMBER_TEMPLATE_FRIENDS."
+#endif
+#ifdef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_MEMBER_TEMPLATE_KEYWORD."
+#endif
+#ifdef BOOST_NO_NESTED_FRIENDSHIP
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_NESTED_FRIENDSHIP."
+#endif
+#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_OPERATORS_IN_NAMESPACE."
+#endif
+#ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS."
+#endif
+#ifdef BOOST_NO_POINTER_TO_MEMBER_CONST
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_POINTER_TO_MEMBER_CONST."
+#endif
+#ifdef BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS."
+#endif
+#ifdef BOOST_NO_PRIVATE_IN_AGGREGATE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_PRIVATE_IN_AGGREGATE."
+#endif
+#ifdef BOOST_NO_RESTRICT_REFERENCES
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_RESTRICT_REFERENCES."
+#endif
+#ifdef BOOST_NO_RTTI
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_RTTI."
+#endif
+#ifdef BOOST_NO_SFINAE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_SFINAE."
+#endif
+#ifdef BOOST_NO_SFINAE_EXPR
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_SFINAE_EXPR."
+#endif
+#ifdef BOOST_NO_STDC_NAMESPACE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STDC_NAMESPACE."
+#endif
+#ifdef BOOST_NO_STD_ALLOCATOR
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_ALLOCATOR."
+#endif
+#ifdef BOOST_NO_STD_DISTANCE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_DISTANCE."
+#endif
+#ifdef BOOST_NO_STD_ITERATOR
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_ITERATOR."
+#endif
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_ITERATOR_TRAITS."
+#endif
+#ifdef BOOST_NO_STD_LOCALE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_LOCALE."
+#endif
+#ifdef BOOST_NO_STD_MESSAGES
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_MESSAGES."
+#endif
+#ifdef BOOST_NO_STD_MIN_MAX
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_MIN_MAX."
+#endif
+#ifdef BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN."
+#endif
+#ifdef BOOST_NO_STD_TYPEINFO
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_TYPEINFO."
+#endif
+#ifdef BOOST_NO_STD_USE_FACET
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_USE_FACET."
+#endif
+#ifdef BOOST_NO_STD_WSTREAMBUF
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_WSTREAMBUF."
+#endif
+#ifdef BOOST_NO_STD_WSTRING
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STD_WSTRING."
+#endif
+#ifdef BOOST_NO_STRINGSTREAM
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_STRINGSTREAM."
+#endif
+#ifdef BOOST_NO_TEMPLATED_IOSTREAMS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_TEMPLATED_IOSTREAMS."
+#endif
+#ifdef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS."
+#endif
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION."
+#endif
+#ifdef BOOST_NO_TEMPLATE_TEMPLATES
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_TEMPLATE_TEMPLATES."
+#endif
+#ifdef BOOST_NO_TWO_PHASE_NAME_LOOKUP
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_TWO_PHASE_NAME_LOOKUP."
+#endif
+#ifdef BOOST_NO_TYPEID
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_TYPEID."
+#endif
+#ifdef BOOST_NO_TYPENAME_WITH_CTOR
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_TYPENAME_WITH_CTOR."
+#endif
+#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_UNREACHABLE_RETURN_DETECTION."
+#endif
+#ifdef BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE."
+#endif
+#ifdef BOOST_NO_USING_TEMPLATE
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_USING_TEMPLATE."
+#endif
+#ifdef BOOST_NO_VOID_RETURNS
+# error "Your compiler appears not to be fully C++03 compliant. Detected via defect macro BOOST_NO_VOID_RETURNS."
+#endif
--- /dev/null
+// This file was automatically generated on Sun Jun 5 16:50:18 2022
+// by libs/config/tools/generate.cpp
+// Copyright John Maddock 2002-21.
+// 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/config for the most recent version.//
+// Revision $Id$
+//
+
+#include <boost/config.hpp>
+#include <boost/config/assert_cxx03.hpp>
+
+#ifdef BOOST_NO_CXX11_ADDRESSOF
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_ADDRESSOF."
+#endif
+#ifdef BOOST_NO_CXX11_ALIGNAS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_ALIGNAS."
+#endif
+#ifdef BOOST_NO_CXX11_ALLOCATOR
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_ALLOCATOR."
+#endif
+#ifdef BOOST_NO_CXX11_AUTO_DECLARATIONS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_AUTO_DECLARATIONS."
+#endif
+#ifdef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS."
+#endif
+#ifdef BOOST_NO_CXX11_CHAR16_T
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_CHAR16_T."
+#endif
+#ifdef BOOST_NO_CXX11_CHAR32_T
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_CHAR32_T."
+#endif
+#ifdef BOOST_NO_CXX11_CONSTEXPR
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_CONSTEXPR."
+#endif
+#ifdef BOOST_NO_CXX11_DECLTYPE
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_DECLTYPE."
+#endif
+#ifdef BOOST_NO_CXX11_DECLTYPE_N3276
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_DECLTYPE_N3276."
+#endif
+#ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_DEFAULTED_FUNCTIONS."
+#endif
+#ifdef BOOST_NO_CXX11_DEFAULTED_MOVES
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_DEFAULTED_MOVES."
+#endif
+#ifdef BOOST_NO_CXX11_DELETED_FUNCTIONS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_DELETED_FUNCTIONS."
+#endif
+#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS."
+#endif
+#ifdef BOOST_NO_CXX11_EXTERN_TEMPLATE
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_EXTERN_TEMPLATE."
+#endif
+#ifdef BOOST_NO_CXX11_FINAL
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_FINAL."
+#endif
+#ifdef BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS."
+#endif
+#ifdef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_ARRAY
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_ARRAY."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_ATOMIC
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_ATOMIC."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_CHRONO
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_CHRONO."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_CONDITION_VARIABLE."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_EXCEPTION
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_EXCEPTION."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_FORWARD_LIST
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_FORWARD_LIST."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_FUNCTIONAL."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_FUTURE
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_FUTURE."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_INITIALIZER_LIST."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_MUTEX
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_MUTEX."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_RANDOM
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_RANDOM."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_RATIO
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_RATIO."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_REGEX
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_REGEX."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_SYSTEM_ERROR."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_THREAD
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_THREAD."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_TUPLE
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_TUPLE."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_TYPEINDEX
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_TYPEINDEX."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_TYPE_TRAITS."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_UNORDERED_MAP
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_UNORDERED_MAP."
+#endif
+#ifdef BOOST_NO_CXX11_HDR_UNORDERED_SET
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_HDR_UNORDERED_SET."
+#endif
+#ifdef BOOST_NO_CXX11_INLINE_NAMESPACES
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_INLINE_NAMESPACES."
+#endif
+#ifdef BOOST_NO_CXX11_LAMBDAS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_LAMBDAS."
+#endif
+#ifdef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS."
+#endif
+#ifdef BOOST_NO_CXX11_NOEXCEPT
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_NOEXCEPT."
+#endif
+#ifdef BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS."
+#endif
+#ifdef BOOST_NO_CXX11_NULLPTR
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_NULLPTR."
+#endif
+#ifdef BOOST_NO_CXX11_NUMERIC_LIMITS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_NUMERIC_LIMITS."
+#endif
+#ifdef BOOST_NO_CXX11_OVERRIDE
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_OVERRIDE."
+#endif
+#ifdef BOOST_NO_CXX11_POINTER_TRAITS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_POINTER_TRAITS."
+#endif
+#ifdef BOOST_NO_CXX11_RANGE_BASED_FOR
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_RANGE_BASED_FOR."
+#endif
+#ifdef BOOST_NO_CXX11_RAW_LITERALS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_RAW_LITERALS."
+#endif
+#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_REF_QUALIFIERS."
+#endif
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_RVALUE_REFERENCES."
+#endif
+#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_SCOPED_ENUMS."
+#endif
+#ifdef BOOST_NO_CXX11_SFINAE_EXPR
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_SFINAE_EXPR."
+#endif
+#ifdef BOOST_NO_CXX11_SMART_PTR
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_SMART_PTR."
+#endif
+#ifdef BOOST_NO_CXX11_STATIC_ASSERT
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_STATIC_ASSERT."
+#endif
+#ifdef BOOST_NO_CXX11_STD_ALIGN
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_STD_ALIGN."
+#endif
+#ifdef BOOST_NO_CXX11_TEMPLATE_ALIASES
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_TEMPLATE_ALIASES."
+#endif
+#ifdef BOOST_NO_CXX11_THREAD_LOCAL
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_THREAD_LOCAL."
+#endif
+#ifdef BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_TRAILING_RESULT_TYPES."
+#endif
+#ifdef BOOST_NO_CXX11_UNICODE_LITERALS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_UNICODE_LITERALS."
+#endif
+#ifdef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX."
+#endif
+#ifdef BOOST_NO_CXX11_UNRESTRICTED_UNION
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_UNRESTRICTED_UNION."
+#endif
+#ifdef BOOST_NO_CXX11_USER_DEFINED_LITERALS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_USER_DEFINED_LITERALS."
+#endif
+#ifdef BOOST_NO_CXX11_VARIADIC_MACROS
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_VARIADIC_MACROS."
+#endif
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+# error "Your compiler appears not to be fully C++11 compliant. Detected via defect macro BOOST_NO_CXX11_VARIADIC_TEMPLATES."
+#endif
--- /dev/null
+// This file was automatically generated on Sun Jun 5 16:50:18 2022
+// by libs/config/tools/generate.cpp
+// Copyright John Maddock 2002-21.
+// 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/config for the most recent version.//
+// Revision $Id$
+//
+
+#include <boost/config.hpp>
+#include <boost/config/assert_cxx11.hpp>
+
+#ifdef BOOST_NO_CXX14_AGGREGATE_NSDMI
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_AGGREGATE_NSDMI."
+#endif
+#ifdef BOOST_NO_CXX14_BINARY_LITERALS
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_BINARY_LITERALS."
+#endif
+#ifdef BOOST_NO_CXX14_CONSTEXPR
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_CONSTEXPR."
+#endif
+#ifdef BOOST_NO_CXX14_DECLTYPE_AUTO
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_DECLTYPE_AUTO."
+#endif
+#ifdef BOOST_NO_CXX14_DIGIT_SEPARATORS
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_DIGIT_SEPARATORS."
+#endif
+#ifdef BOOST_NO_CXX14_GENERIC_LAMBDAS
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_GENERIC_LAMBDAS."
+#endif
+#ifdef BOOST_NO_CXX14_HDR_SHARED_MUTEX
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_HDR_SHARED_MUTEX."
+#endif
+#ifdef BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES."
+#endif
+#ifdef BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION."
+#endif
+#ifdef BOOST_NO_CXX14_STD_EXCHANGE
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_STD_EXCHANGE."
+#endif
+#ifdef BOOST_NO_CXX14_VARIABLE_TEMPLATES
+# error "Your compiler appears not to be fully C++14 compliant. Detected via defect macro BOOST_NO_CXX14_VARIABLE_TEMPLATES."
+#endif
--- /dev/null
+// This file was automatically generated on Sun Jun 5 16:50:18 2022
+// by libs/config/tools/generate.cpp
+// Copyright John Maddock 2002-21.
+// 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/config for the most recent version.//
+// Revision $Id$
+//
+
+#include <boost/config.hpp>
+#include <boost/config/assert_cxx14.hpp>
+
+#ifdef BOOST_NO_CXX17_DEDUCTION_GUIDES
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_DEDUCTION_GUIDES."
+#endif
+#ifdef BOOST_NO_CXX17_FOLD_EXPRESSIONS
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_FOLD_EXPRESSIONS."
+#endif
+#ifdef BOOST_NO_CXX17_HDR_ANY
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_HDR_ANY."
+#endif
+#ifdef BOOST_NO_CXX17_HDR_CHARCONV
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_HDR_CHARCONV."
+#endif
+#ifdef BOOST_NO_CXX17_HDR_EXECUTION
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_HDR_EXECUTION."
+#endif
+#ifdef BOOST_NO_CXX17_HDR_FILESYSTEM
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_HDR_FILESYSTEM."
+#endif
+#ifdef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_HDR_MEMORY_RESOURCE."
+#endif
+#ifdef BOOST_NO_CXX17_HDR_OPTIONAL
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_HDR_OPTIONAL."
+#endif
+#ifdef BOOST_NO_CXX17_HDR_STRING_VIEW
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_HDR_STRING_VIEW."
+#endif
+#ifdef BOOST_NO_CXX17_HDR_VARIANT
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_HDR_VARIANT."
+#endif
+#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_IF_CONSTEXPR."
+#endif
+#ifdef BOOST_NO_CXX17_INLINE_VARIABLES
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_INLINE_VARIABLES."
+#endif
+#ifdef BOOST_NO_CXX17_ITERATOR_TRAITS
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_ITERATOR_TRAITS."
+#endif
+#ifdef BOOST_NO_CXX17_STD_APPLY
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_STD_APPLY."
+#endif
+#ifdef BOOST_NO_CXX17_STD_INVOKE
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_STD_INVOKE."
+#endif
+#ifdef BOOST_NO_CXX17_STRUCTURED_BINDINGS
+# error "Your compiler appears not to be fully C++17 compliant. Detected via defect macro BOOST_NO_CXX17_STRUCTURED_BINDINGS."
+#endif
--- /dev/null
+// This file was automatically generated on Sun Jun 5 16:50:18 2022
+// by libs/config/tools/generate.cpp
+// Copyright John Maddock 2002-21.
+// 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/config for the most recent version.//
+// Revision $Id$
+//
+
+#include <boost/config.hpp>
+#include <boost/config/assert_cxx17.hpp>
+
+#ifdef BOOST_NO_CXX20_HDR_BARRIER
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_BARRIER."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_BIT
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_BIT."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_COMPARE
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_COMPARE."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_CONCEPTS
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_CONCEPTS."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_COROUTINE
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_COROUTINE."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_FORMAT
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_FORMAT."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_LATCH
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_LATCH."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_NUMBERS
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_NUMBERS."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_RANGES
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_RANGES."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_SEMAPHORE
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_SEMAPHORE."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_SOURCE_LOCATION
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_SOURCE_LOCATION."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_SPAN
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_SPAN."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_STOP_TOKEN
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_STOP_TOKEN."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_SYNCSTREAM
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_SYNCSTREAM."
+#endif
+#ifdef BOOST_NO_CXX20_HDR_VERSION
+# error "Your compiler appears not to be fully C++20 compliant. Detected via defect macro BOOST_NO_CXX20_HDR_VERSION."
+#endif
--- /dev/null
+// This file was automatically generated on Wed Mar 3 08:46:11 2021
+// by libs/config/tools/generate.cpp
+// Copyright John Maddock 2002-4.
+// 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/config for the most recent version.//
+// Revision $Id$
+//
+
+#include <boost/config.hpp>
+#include <boost/config/assert_cxx17.hpp>
+
+#ifdef BOOST_NO_CXX98_BINDERS
+# error "Your compiler appears not to be fully C++98 compliant. Detected via defect macro BOOST_NO_CXX98_BINDERS."
+#endif
+#ifdef BOOST_NO_CXX98_FUNCTION_BASE
+# error "Your compiler appears not to be fully C++98 compliant. Detected via defect macro BOOST_NO_CXX98_FUNCTION_BASE."
+#endif
+#ifdef BOOST_NO_CXX98_RANDOM_SHUFFLE
+# error "Your compiler appears not to be fully C++98 compliant. Detected via defect macro BOOST_NO_CXX98_RANDOM_SHUFFLE."
+#endif
+ BOOST_LIB_ARCH_AND_MODEL_OPT
"-"
+ BOOST_LIB_VERSION
+ + BOOST_LIB_SUFFIX
These are defined as:
BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y.
+BOOST_LIB_SUFFIX: Static/import libraries extension (".lib", ".a") for the compiler.
***************************************************************************/
// Only include what follows for known and supported compilers:
//
#if defined(BOOST_MSVC) \
- || defined(__BORLANDC__) \
+ || defined(BOOST_EMBTC_WINDOWS) \
+ || defined(BOOST_BORLANDC) \
|| (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \
|| (defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200)) \
|| (defined(BOOST_CLANG) && defined(BOOST_WINDOWS) && defined(_MSC_VER) && (__clang_major__ >= 4))
// vc14.1:
# define BOOST_LIB_TOOLSET "vc141"
-# elif defined(BOOST_MSVC)
+# elif defined(BOOST_MSVC) && (BOOST_MSVC < 1930)
// vc14.2:
# define BOOST_LIB_TOOLSET "vc142"
-# elif defined(__BORLANDC__)
+# elif defined(BOOST_MSVC)
+
+ // vc14.3:
+# define BOOST_LIB_TOOLSET "vc143"
+
+# elif defined(BOOST_EMBTC_WINDOWS)
+
+ // Embarcadero Clang based compilers:
+# define BOOST_LIB_TOOLSET "embtc"
+
+# elif defined(BOOST_BORLANDC)
// CBuilder 6:
# define BOOST_LIB_TOOLSET "bcb"
# endif
-#elif defined(__BORLANDC__)
+#elif defined(BOOST_EMBTC_WINDOWS)
+
+# ifdef _RTLDLL
+
+# if defined(_DEBUG)
+# define BOOST_LIB_RT_OPT "-d"
+# else
+# define BOOST_LIB_RT_OPT
+# endif
+
+# else
+
+# if defined(_DEBUG)
+# define BOOST_LIB_RT_OPT "-sd"
+# else
+# define BOOST_LIB_RT_OPT "-s"
+# endif
+
+# endif
+
+#elif defined(BOOST_BORLANDC)
//
// figure out whether we want the debug builds or not:
//
-#if __BORLANDC__ > 0x561
+#if BOOST_BORLANDC > 0x561
#pragma defineonoption BOOST_BORLAND_DEBUG -v
#endif
//
# elif defined(BOOST_BORLAND_DEBUG)
# define BOOST_LIB_RT_OPT "-d"
# elif defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
-# define BOOST_LIB_RT_OPT -y
+# define BOOST_LIB_RT_OPT "-y"
# else
# define BOOST_LIB_RT_OPT
# endif
&& defined(BOOST_LIB_ARCH_AND_MODEL_OPT) \
&& defined(BOOST_LIB_VERSION)
-#ifdef BOOST_AUTO_LINK_TAGGED
-# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT ".lib")
+#if defined(BOOST_EMBTC_WIN64)
+# define BOOST_LIB_SUFFIX ".a"
+#else
+# define BOOST_LIB_SUFFIX ".lib"
+#endif
+
+#ifdef BOOST_AUTO_LINK_NOMANGLE
+# pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_SUFFIX)
# ifdef BOOST_LIB_DIAGNOSTIC
-# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT ".lib")
+# pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_SUFFIX)
# endif
-#elif defined(BOOST_AUTO_LINK_SYSTEM)
-# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+#elif defined(BOOST_AUTO_LINK_TAGGED)
+# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT BOOST_LIB_SUFFIX)
# ifdef BOOST_LIB_DIAGNOSTIC
-# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT BOOST_LIB_SUFFIX)
# endif
-#elif defined(BOOST_AUTO_LINK_NOMANGLE)
-# pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+#elif defined(BOOST_AUTO_LINK_SYSTEM)
+# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_SUFFIX)
# ifdef BOOST_LIB_DIAGNOSTIC
-# pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_SUFFIX)
# endif
#elif defined(BOOST_LIB_BUILDID)
-# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) ".lib")
+# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) BOOST_LIB_SUFFIX)
# ifdef BOOST_LIB_DIAGNOSTIC
-# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) ".lib")
+# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) BOOST_LIB_SUFFIX)
# endif
#else
-# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION ".lib")
+# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION BOOST_LIB_SUFFIX)
# ifdef BOOST_LIB_DIAGNOSTIC
-# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION ".lib")
+# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION BOOST_LIB_SUFFIX)
# endif
#endif
#if defined(BOOST_DYN_LINK)
# undef BOOST_DYN_LINK
#endif
-
-
+#if defined(BOOST_LIB_SUFFIX)
+# undef BOOST_LIB_SUFFIX
+#endif
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
// (Niels Dekker, LKEB, April 2010)
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
-#define BOOST_COMPILER "Borland C++ version " BOOST_STRINGIZE(__BORLANDC__)
+#define BOOST_BORLANDC __BORLANDC__
+#define BOOST_COMPILER "Classic Borland C++ version " BOOST_STRINGIZE(__BORLANDC__)
#if !__has_feature(cxx_override_control)
# define BOOST_NO_CXX11_FINAL
+# define BOOST_NO_CXX11_OVERRIDE
+#endif
+
+#if !__has_feature(cxx_unrestricted_unions)
+# define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif
#if !(__has_feature(__cxx_binary_literals__) || __has_extension(__cxx_binary_literals__))
// All versions with __cplusplus above this value seem to support this:
# define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
-//
-// __builtin_unreachable:
-#if defined(__has_builtin) && __has_builtin(__builtin_unreachable)
+
+// Unreachable code markup
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_unreachable)
#define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
#endif
+#endif
+
+// Deprecated symbol markup
+#if __has_attribute(deprecated)
+#define BOOST_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#endif
#if (__clang_major__ == 3) && (__clang_minor__ == 0)
// Apparently a clang bug:
// Macro used to identify the Clang compiler.
#define BOOST_CLANG 1
+// BOOST_CLANG_VERSION
+#include <boost/config/compiler/clang_version.hpp>
--- /dev/null
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(__APPLE__)
+
+# define BOOST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__ % 100)
+
+#else
+# define BOOST_CLANG_REPORTED_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__ % 100)
+
+// https://en.wikipedia.org/wiki/Xcode#Toolchain_versions
+
+# if BOOST_CLANG_REPORTED_VERSION >= 140000
+# define BOOST_CLANG_VERSION 140000
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 130100
+# define BOOST_CLANG_VERSION 130000
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 130000
+# define BOOST_CLANG_VERSION 120000
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 120005
+# define BOOST_CLANG_VERSION 110100
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 120000
+# define BOOST_CLANG_VERSION 100000
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 110003
+# define BOOST_CLANG_VERSION 90000
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 110000
+# define BOOST_CLANG_VERSION 80000
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 100001
+# define BOOST_CLANG_VERSION 70000
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 100000
+# define BOOST_CLANG_VERSION 60001
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 90100
+# define BOOST_CLANG_VERSION 50002
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 90000
+# define BOOST_CLANG_VERSION 40000
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 80000
+# define BOOST_CLANG_VERSION 30900
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 70300
+# define BOOST_CLANG_VERSION 30800
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 70000
+# define BOOST_CLANG_VERSION 30700
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 60100
+# define BOOST_CLANG_VERSION 30600
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 60000
+# define BOOST_CLANG_VERSION 30500
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 50100
+# define BOOST_CLANG_VERSION 30400
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 50000
+# define BOOST_CLANG_VERSION 30300
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 40200
+# define BOOST_CLANG_VERSION 30200
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 30100
+# define BOOST_CLANG_VERSION 30100
+
+# elif BOOST_CLANG_REPORTED_VERSION >= 20100
+# define BOOST_CLANG_VERSION 30000
+
+# else
+# define BOOST_CLANG_VERSION 20900
+
+# endif
+
+# undef BOOST_CLANG_REPORTED_VERSION
+#endif
// CodeGear C++ compiler setup:
-#if !defined( BOOST_WITH_CODEGEAR_WARNINGS )
-// these warnings occur frequently in optimized template code
-# pragma warn -8004 // var assigned value, but never used
-# pragma warn -8008 // condition always true/false
-# pragma warn -8066 // dead code can never execute
-# pragma warn -8104 // static members with ctors not threadsafe
-# pragma warn -8105 // reference member in class without ctors
-#endif
//
// versions check:
-// last known and checked version is 0x621
-#if (__CODEGEARC__ > 0x621)
+// last known and checked version is 0x740
+#if (__CODEGEARC__ > 0x740)
# if defined(BOOST_ASSERT_CONFIG)
# error "boost: Unknown compiler version - please run the configure tests and report the results"
# else
# endif
#endif
+#ifdef __clang__ // Clang enhanced Windows compiler
+
+# include "clang.hpp"
+# define BOOST_NO_CXX11_THREAD_LOCAL
+# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+
+// This bug has been reported to Embarcadero
+
+#if defined(BOOST_HAS_INT128)
+#undef BOOST_HAS_INT128
+#endif
+#if defined(BOOST_HAS_FLOAT128)
+#undef BOOST_HAS_FLOAT128
+#endif
+
+// The clang-based compilers can not do 128 atomic exchanges
+
+#define BOOST_ATOMIC_NO_CMPXCHG16B
+
+// 32 functions are missing from the current RTL in cwchar, so it really can not be used even if it exists
+
+# define BOOST_NO_CWCHAR
+
+# ifndef __MT__ /* If compiling in single-threaded mode, assume there is no CXX11_HDR_ATOMIC */
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# endif
+
+/* temporarily disable this until we can link against fegetround fesetround feholdexcept */
+
+#define BOOST_NO_FENV_H
+
+/* Reported this bug to Embarcadero with the latest C++ Builder Rio release */
+
+#define BOOST_NO_CXX11_HDR_EXCEPTION
+
+//
+// check for exception handling support:
+//
+#if !defined(_CPPUNWIND) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
+# define BOOST_NO_EXCEPTIONS
+#endif
+
+/*
+
+// On non-Win32 platforms let the platform config figure this out:
+#ifdef _WIN32
+# define BOOST_HAS_STDINT_H
+#endif
+
+//
+// __int64:
+//
+#if !defined(__STRICT_ANSI__)
+# define BOOST_HAS_MS_INT64
+#endif
+//
+// all versions have a <dirent.h>:
+//
+#if !defined(__STRICT_ANSI__)
+# define BOOST_HAS_DIRENT_H
+#endif
+//
+// Disable Win32 support in ANSI mode:
+//
+# pragma defineonoption BOOST_DISABLE_WIN32 -A
+//
+// MSVC compatibility mode does some nasty things:
+// TODO: look up if this doesn't apply to the whole 12xx range
+//
+#if defined(_MSC_VER) && (_MSC_VER <= 1200)
+# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+# define BOOST_NO_VOID_RETURNS
+#endif
+//
+
+*/
+
+// Specific settings for Embarcadero drivers
+# define BOOST_EMBTC __CODEGEARC__
+# define BOOST_EMBTC_FULL_VER ((__clang_major__ << 16) | \
+ (__clang_minor__ << 8) | \
+ __clang_patchlevel__ )
+
+// Detecting which Embarcadero driver is being used
+#if defined(BOOST_EMBTC)
+# if defined(_WIN64)
+# define BOOST_EMBTC_WIN64 1
+# define BOOST_EMBTC_WINDOWS 1
+# ifndef BOOST_USE_WINDOWS_H
+# define BOOST_USE_WINDOWS_H
+# endif
+# elif defined(_WIN32)
+# define BOOST_EMBTC_WIN32C 1
+# define BOOST_EMBTC_WINDOWS 1
+# ifndef BOOST_USE_WINDOWS_H
+# define BOOST_USE_WINDOWS_H
+# endif
+# elif defined(__APPLE__) && defined(__arm__)
+# define BOOST_EMBTC_IOSARM 1
+# define BOOST_EMBTC_IOS 1
+# elif defined(__APPLE__) && defined(__aarch64__)
+# define BOOST_EMBTC_IOSARM64 1
+# define BOOST_EMBTC_IOS 1
+# elif defined(__ANDROID__) && defined(__arm__)
+# define BOOST_EMBTC_AARM 1
+# define BOOST_EMBTC_ANDROID 1
+# elif
+# if defined(BOOST_ASSERT_CONFIG)
+# error "Unknown Embarcadero driver"
+# else
+# warning "Unknown Embarcadero driver"
+# endif /* defined(BOOST_ASSERT_CONFIG) */
+# endif
+#endif /* defined(BOOST_EMBTC) */
+
+#if defined(BOOST_EMBTC_WINDOWS)
+
+#if !defined(_chdir)
+#define _chdir(x) chdir(x)
+#endif
+
+#if !defined(_dup2)
+#define _dup2(x,y) dup2(x,y)
+#endif
+
+#endif
+
+# undef BOOST_COMPILER
+# define BOOST_COMPILER "Embarcadero-Clang C++ version " BOOST_STRINGIZE(__CODEGEARC__) " clang: " __clang_version__
+// # define __CODEGEARC_CLANG__ __CODEGEARC__
+// # define __EMBARCADERO_CLANG__ __CODEGEARC__
+// # define __BORLANDC_CLANG__ __BORLANDC__
+
+#else // #if !defined(__clang__)
+
+# define BOOST_CODEGEARC __CODEGEARC__
+# define BOOST_BORLANDC __BORLANDC__
+
+#if !defined( BOOST_WITH_CODEGEAR_WARNINGS )
+// these warnings occur frequently in optimized template code
+# pragma warn -8004 // var assigned value, but never used
+# pragma warn -8008 // condition always true/false
+# pragma warn -8066 // dead code can never execute
+# pragma warn -8104 // static members with ctors not threadsafe
+# pragma warn -8105 // reference member in class without ctors
+#endif
+
// CodeGear C++ Builder 2009
#if (__CODEGEARC__ <= 0x613)
# define BOOST_NO_INTEGRAL_INT64_T
# define BOOST_HAS_PRAGMA_ONCE
#endif
+#define BOOST_NO_FENV_H
+
//
// C++0x macros:
//
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_COMPILER "CodeGear C++ version " BOOST_STRINGIZE(__CODEGEARC__)
+#endif // #if !defined(__clang__)
#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
-#define BOOST_NO_CXX11_CHAR16_T
-#define BOOST_NO_CXX11_CHAR32_T
-#define BOOST_NO_CXX11_CONSTEXPR
-#define BOOST_NO_CXX11_DECLTYPE
-#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
-#define BOOST_NO_CXX11_RANGE_BASED_FOR
-#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
-#define BOOST_NO_CXX11_UNICODE_LITERALS
-#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
+
+//__cpp_decltype 200707 possibly?
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+
+#if !defined(__cpp_unicode_characters) || (__cpp_unicode_characters < 200704)
+# define BOOST_NO_CXX11_CHAR16_T
+# define BOOST_NO_CXX11_CHAR32_T
+#endif
+#if !defined(__cpp_unicode_literals) || (__cpp_unicode_literals < 200710)
+# define BOOST_NO_CXX11_UNICODE_LITERALS
+#endif
+#if !defined(__cpp_user_defined_literals) || (__cpp_user_defined_literals < 200809)
+# define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#endif
+#if !defined(__cpp_variadic_templates) || (__cpp_variadic_templates < 200704)
+# define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 200907)
+# define BOOST_NO_CXX11_CONSTEXPR
+#endif
+#if !defined(__cpp_lambdas) || (__cpp_lambdas < 200907)
+# define BOOST_NO_CXX11_LAMBDAS
+#endif
+#if !defined(__cpp_range_based_for) || (__cpp_range_based_for < 200710)
+# define BOOST_NO_CXX11_RANGE_BASED_FOR
+#endif
+#if !defined(__cpp_raw_strings) || (__cpp_raw_strings < 200610)
+# define BOOST_NO_CXX11_RAW_LITERALS
+#endif
+
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_VARIADIC_MACROS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#undef BOOST_NO_CXX11_DELETED_FUNCTIONS
#undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#undef BOOST_NO_CXX11_FINAL
+#undef BOOST_NO_CXX11_OVERRIDE
#undef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#undef BOOST_NO_CXX11_LAMBDAS
#undef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#undef BOOST_NO_CXX11_USER_DEFINED_LITERALS
#undef BOOST_NO_CXX11_VARIADIC_MACROS
#undef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#undef BOOST_NO_CXX11_UNRESTRICTED_UNION
#undef BOOST_NO_SFINAE_EXPR
#undef BOOST_NO_TWO_PHASE_NAME_LOOKUP
#undef BOOST_MATH_DISABLE_STD_FPCLASSIFY
#undef BOOST_NO_CXX11_CHAR32_T
#undef BOOST_NO_CXX11_INLINE_NAMESPACES
#undef BOOST_NO_CXX11_FINAL
+#undef BOOST_NO_CXX11_OVERRIDE
#undef BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#undef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_SFINAE_EXPR // This is correct, even though '*_fail.cpp' test fails.
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
# define BOOST_NO_CXX11_TEMPLATE_ALIASES
# define BOOST_NO_CXX11_USER_DEFINED_LITERALS
# define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+# define BOOST_NO_CXX11_OVERRIDE
#endif
// C++0x features in 4.8.n and later
//
#if (BOOST_GCC_VERSION < 40800) || !defined(BOOST_GCC_CXX11)
-# define BOOST_NO_CXX11_ALIGNAS
# define BOOST_NO_CXX11_THREAD_LOCAL
# define BOOST_NO_CXX11_SFINAE_EXPR
#endif
# define BOOST_NO_CXX14_BINARY_LITERALS
#endif
+// C++0x features in 4.9.n and later
+//
+#if (BOOST_GCC_VERSION < 40900) || !defined(BOOST_GCC_CXX11)
+// Although alignas support is added in gcc 4.8, it does not accept
+// dependent constant expressions as an argument until gcc 4.9.
+# define BOOST_NO_CXX11_ALIGNAS
+#endif
+
+// C++0x features in 5.1 and later
+//
+#if (BOOST_GCC_VERSION < 50100) || !defined(BOOST_GCC_CXX11)
+# define BOOST_NO_CXX11_UNRESTRICTED_UNION
+#endif
+
// C++14 features in 4.9.0 and later
//
#if (BOOST_GCC_VERSION < 40900) || (__cplusplus < 201300)
# define BOOST_FALLTHROUGH __attribute__((fallthrough))
#endif
-#if defined(__MINGW32__) && !defined(__MINGW64__)
-// Currently (March 2019) thread_local is broken on mingw for all current 32bit compiler releases, see
+#if (__GNUC__ < 11) && defined(__MINGW32__) && !defined(__MINGW64__)
+// thread_local was broken on mingw for all 32bit compiler releases prior to 11.x, see
// https://sourceforge.net/p/mingw-w64/bugs/527/
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83562
// Not setting this causes program termination on thread exit.
#define BOOST_NO_CXX11_THREAD_LOCAL
#endif
// Type aliasing hint. Supported since gcc 3.3.
#define BOOST_MAY_ALIAS __attribute__((__may_alias__))
-//
-// __builtin_unreachable:
+// Unreachable code markup
#if BOOST_GCC_VERSION >= 40500
#define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
#endif
+// Deprecated symbol markup
+#if BOOST_GCC_VERSION >= 40500
+#define BOOST_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#else
+#define BOOST_DEPRECATED(msg) __attribute__((deprecated))
+#endif
+
#ifndef BOOST_COMPILER
# define BOOST_COMPILER "GNU C++ version " __VERSION__
#endif
// versions check:
// we don't know gcc prior to version 3.30:
-#if (BOOST_GCC_VERSION< 30300)
+#if (BOOST_GCC_VERSION < 30300)
# error "Compiler not configured - please reconfigure"
#endif
//
# define BOOST_NO_CXX11_INLINE_NAMESPACES
# define BOOST_NO_CXX11_REF_QUALIFIERS
# define BOOST_NO_CXX11_FINAL
+# define BOOST_NO_CXX11_OVERRIDE
# define BOOST_NO_CXX11_THREAD_LOCAL
+# define BOOST_NO_CXX11_UNRESTRICTED_UNION
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
/*
See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and
#endif
// BOOST_NO_CXX11_FINAL
+// BOOST_NO_CXX11_OVERRIDE
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40700)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
# undef BOOST_NO_CXX11_FINAL
+# undef BOOST_NO_CXX11_OVERRIDE
+#endif
+
+// BOOST_NO_CXX11_UNRESTRICTED_UNION
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 50100)) && (!defined(_MSC_VER))
+# undef BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif
#endif // defined(BOOST_INTEL_STDCXX0X)
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
// BOOST_GPU_ENABLED : Flag a function or a method as being enabled on the host and device
#define BOOST_GPU_ENABLED __host__ __device__
+#if !defined(__clang__) || defined(__NVCC__)
// A bug in version 7.0 of CUDA prevents use of variadic templates in some occasions
// https://svn.boost.org/trac/boost/ticket/11897
// This is fixed in 7.5. As the following version macro was introduced in 7.5 an existance
# define BOOST_NO_CXX11_CONSTEXPR
#endif
+#endif
+
#ifdef __CUDACC__
//
// When compiing .cu files, there's a bunch of stuff that doesn't work with msvc:
# define BOOST_NO_CXX11_INLINE_NAMESPACES
# define BOOST_NO_CXX11_REF_QUALIFIERS
# define BOOST_NO_CXX11_FINAL
+# define BOOST_NO_CXX11_OVERRIDE
# define BOOST_NO_CXX11_THREAD_LOCAL
+# define BOOST_NO_CXX11_UNRESTRICTED_UNION
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
# define BOOST_SYMBOL_VISIBLE __global
#endif
+// Deprecated symbol markup
+// Oracle Studio 12.4 supports deprecated attribute with a message; this is the first release that supports the attribute.
+#if (__SUNPRO_CC >= 0x5130)
+#define BOOST_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#endif
+
#if (__SUNPRO_CC < 0x5130)
// C++03 features in 12.4:
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif
#if (__SUNPRO_CC < 0x5140) || (__cplusplus < 201103)
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
# define BOOST_NO_RTTI
#endif
+// Deprecated symbol markup
+#if (_MSC_VER >= 1400)
+#define BOOST_DEPRECATED(msg) __declspec(deprecated(msg))
+#else
+// MSVC 7.1 only supports the attribute without a message
+#define BOOST_DEPRECATED(msg) __declspec(deprecated)
+#endif
+
//
// TR1 features:
//
# define BOOST_NO_CXX11_FINAL
# define BOOST_NO_CXX11_RANGE_BASED_FOR
# define BOOST_NO_CXX11_SCOPED_ENUMS
+# define BOOST_NO_CXX11_OVERRIDE
#endif // _MSC_VER < 1700
// C++11 features supported by VC++ 12 (aka 2013).
# define BOOST_NO_CXX14_GENERIC_LAMBDAS
# define BOOST_NO_CXX14_DIGIT_SEPARATORS
# define BOOST_NO_CXX11_THREAD_LOCAL
+# define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif
// C++11 features supported by VC++ 14 update 3 (aka 2015)
//
// if this is in effect or not, in any case nothing in Boost is currently using this, so we'll just go
// on defining it for now:
//
+#if (_MSC_FULL_VER < 193030705) || (_MSVC_LANG < 202004)
# define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#endif
#if (_MSC_VER < 1912) || (_MSVC_LANG < 201402)
// Supported from msvc-15.5 onwards:
# define BOOST_ABI_SUFFIX "boost/config/abi/msvc_suffix.hpp"
#endif
+//
+// Approximate compiler conformance version
+//
+#ifdef _MSVC_LANG
+# define BOOST_CXX_VERSION _MSVC_LANG
+#elif defined(_HAS_CXX17)
+# define BOOST_CXX_VERSION 201703L
+#elif BOOST_MSVC >= 1916
+# define BOOST_CXX_VERSION 201402L
+#endif
+
#ifndef BOOST_COMPILER
// TODO:
// these things are mostly bogus. 1200 means version 12.0 of the compiler. The
#if !__has_feature(cxx_override_control)
# define BOOST_NO_CXX11_FINAL
+# define BOOST_NO_CXX11_OVERRIDE
+#endif
+
+#if !__has_feature(cxx_unrestricted_unions)
+# define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif
#if !(__has_feature(__cxx_binary_literals__) || __has_extension(__cxx_binary_literals__))
# define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
+// Deprecated symbol markup
+#if __has_attribute(deprecated)
+#define BOOST_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#endif
// Unused attribute:
#if defined(__GNUC__) && (__GNUC__ >= 4)
// Macro used to identify the Clang compiler.
#define BOOST_CLANG 1
+#define BOOST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_UNRESTRICTED_UNION
#define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#define BOOST_NO_CXX14_AGGREGATE_NSDMI
--- /dev/null
+// This file was automatically generated on Sun Jun 5 16:50:18 2022
+// by libs/config/tools/generate.cpp
+// Copyright John Maddock 2002-21.
+// 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/config for the most recent version.//
+// Revision $Id$
+//
+
+#if defined(BOOST_NO_ADL_BARRIER)\
+ || defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)\
+ || defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)\
+ || defined(BOOST_NO_COMPLETE_VALUE_INITIALIZATION)\
+ || defined(BOOST_NO_CTYPE_FUNCTIONS)\
+ || defined(BOOST_NO_CV_SPECIALIZATIONS)\
+ || defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)\
+ || defined(BOOST_NO_CWCHAR)\
+ || defined(BOOST_NO_CWCTYPE)\
+ || defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)\
+ || defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS)\
+ || defined(BOOST_NO_EXCEPTIONS)\
+ || defined(BOOST_NO_EXCEPTION_STD_NAMESPACE)\
+ || defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)\
+ || defined(BOOST_NO_FENV_H)\
+ || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)\
+ || defined(BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS)\
+ || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)\
+ || defined(BOOST_NO_INTEGRAL_INT64_T)\
+ || defined(BOOST_NO_INTRINSIC_WCHAR_T)\
+ || defined(BOOST_NO_IOSFWD)\
+ || defined(BOOST_NO_IOSTREAM)\
+ || defined(BOOST_NO_IS_ABSTRACT)\
+ || defined(BOOST_NO_LIMITS)\
+ || defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)\
+ || defined(BOOST_NO_LONG_LONG)\
+ || defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)\
+ || defined(BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS)\
+ || defined(BOOST_NO_MEMBER_TEMPLATES)\
+ || defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)\
+ || defined(BOOST_NO_MEMBER_TEMPLATE_KEYWORD)\
+ || defined(BOOST_NO_NESTED_FRIENDSHIP)\
+ || defined(BOOST_NO_OPERATORS_IN_NAMESPACE)\
+ || defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)\
+ || defined(BOOST_NO_POINTER_TO_MEMBER_CONST)\
+ || defined(BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS)\
+ || defined(BOOST_NO_PRIVATE_IN_AGGREGATE)\
+ || defined(BOOST_NO_RESTRICT_REFERENCES)\
+ || defined(BOOST_NO_RTTI)\
+ || defined(BOOST_NO_SFINAE)\
+ || defined(BOOST_NO_SFINAE_EXPR)\
+ || defined(BOOST_NO_STDC_NAMESPACE)\
+ || defined(BOOST_NO_STD_ALLOCATOR)\
+ || defined(BOOST_NO_STD_DISTANCE)\
+ || defined(BOOST_NO_STD_ITERATOR)\
+ || defined(BOOST_NO_STD_ITERATOR_TRAITS)\
+ || defined(BOOST_NO_STD_LOCALE)\
+ || defined(BOOST_NO_STD_MESSAGES)\
+ || defined(BOOST_NO_STD_MIN_MAX)\
+ || defined(BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN)\
+ || defined(BOOST_NO_STD_TYPEINFO)\
+ || defined(BOOST_NO_STD_USE_FACET)\
+ || defined(BOOST_NO_STD_WSTREAMBUF)\
+ || defined(BOOST_NO_STD_WSTRING)\
+ || defined(BOOST_NO_STRINGSTREAM)\
+ || defined(BOOST_NO_TEMPLATED_IOSTREAMS)\
+ || defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
+ || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)\
+ || defined(BOOST_NO_TEMPLATE_TEMPLATES)\
+ || defined(BOOST_NO_TWO_PHASE_NAME_LOOKUP)\
+ || defined(BOOST_NO_TYPEID)\
+ || defined(BOOST_NO_TYPENAME_WITH_CTOR)\
+ || defined(BOOST_NO_UNREACHABLE_RETURN_DETECTION)\
+ || defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)\
+ || defined(BOOST_NO_USING_TEMPLATE)\
+ || defined(BOOST_NO_VOID_RETURNS)
+# define BOOST_NO_CXX03
+#endif
+
+#if defined(BOOST_NO_CXX03)\
+ || defined(BOOST_NO_CXX11_ADDRESSOF)\
+ || defined(BOOST_NO_CXX11_ALIGNAS)\
+ || defined(BOOST_NO_CXX11_ALLOCATOR)\
+ || defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)\
+ || defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS)\
+ || defined(BOOST_NO_CXX11_CHAR16_T)\
+ || defined(BOOST_NO_CXX11_CHAR32_T)\
+ || defined(BOOST_NO_CXX11_CONSTEXPR)\
+ || defined(BOOST_NO_CXX11_DECLTYPE)\
+ || defined(BOOST_NO_CXX11_DECLTYPE_N3276)\
+ || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)\
+ || defined(BOOST_NO_CXX11_DEFAULTED_MOVES)\
+ || defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)\
+ || defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)\
+ || defined(BOOST_NO_CXX11_EXTERN_TEMPLATE)\
+ || defined(BOOST_NO_CXX11_FINAL)\
+ || defined(BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS)\
+ || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)\
+ || defined(BOOST_NO_CXX11_HDR_ARRAY)\
+ || defined(BOOST_NO_CXX11_HDR_ATOMIC)\
+ || defined(BOOST_NO_CXX11_HDR_CHRONO)\
+ || defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE)\
+ || defined(BOOST_NO_CXX11_HDR_EXCEPTION)\
+ || defined(BOOST_NO_CXX11_HDR_FORWARD_LIST)\
+ || defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)\
+ || defined(BOOST_NO_CXX11_HDR_FUTURE)\
+ || defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)\
+ || defined(BOOST_NO_CXX11_HDR_MUTEX)\
+ || defined(BOOST_NO_CXX11_HDR_RANDOM)\
+ || defined(BOOST_NO_CXX11_HDR_RATIO)\
+ || defined(BOOST_NO_CXX11_HDR_REGEX)\
+ || defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)\
+ || defined(BOOST_NO_CXX11_HDR_THREAD)\
+ || defined(BOOST_NO_CXX11_HDR_TUPLE)\
+ || defined(BOOST_NO_CXX11_HDR_TYPEINDEX)\
+ || defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)\
+ || defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP)\
+ || defined(BOOST_NO_CXX11_HDR_UNORDERED_SET)\
+ || defined(BOOST_NO_CXX11_INLINE_NAMESPACES)\
+ || defined(BOOST_NO_CXX11_LAMBDAS)\
+ || defined(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS)\
+ || defined(BOOST_NO_CXX11_NOEXCEPT)\
+ || defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)\
+ || defined(BOOST_NO_CXX11_NULLPTR)\
+ || defined(BOOST_NO_CXX11_NUMERIC_LIMITS)\
+ || defined(BOOST_NO_CXX11_OVERRIDE)\
+ || defined(BOOST_NO_CXX11_POINTER_TRAITS)\
+ || defined(BOOST_NO_CXX11_RANGE_BASED_FOR)\
+ || defined(BOOST_NO_CXX11_RAW_LITERALS)\
+ || defined(BOOST_NO_CXX11_REF_QUALIFIERS)\
+ || defined(BOOST_NO_CXX11_RVALUE_REFERENCES)\
+ || defined(BOOST_NO_CXX11_SCOPED_ENUMS)\
+ || defined(BOOST_NO_CXX11_SFINAE_EXPR)\
+ || defined(BOOST_NO_CXX11_SMART_PTR)\
+ || defined(BOOST_NO_CXX11_STATIC_ASSERT)\
+ || defined(BOOST_NO_CXX11_STD_ALIGN)\
+ || defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)\
+ || defined(BOOST_NO_CXX11_THREAD_LOCAL)\
+ || defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES)\
+ || defined(BOOST_NO_CXX11_UNICODE_LITERALS)\
+ || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)\
+ || defined(BOOST_NO_CXX11_UNRESTRICTED_UNION)\
+ || defined(BOOST_NO_CXX11_USER_DEFINED_LITERALS)\
+ || defined(BOOST_NO_CXX11_VARIADIC_MACROS)\
+ || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+# define BOOST_NO_CXX11
+#endif
+
+#if defined(BOOST_NO_CXX11)\
+ || defined(BOOST_NO_CXX14_AGGREGATE_NSDMI)\
+ || defined(BOOST_NO_CXX14_BINARY_LITERALS)\
+ || defined(BOOST_NO_CXX14_CONSTEXPR)\
+ || defined(BOOST_NO_CXX14_DECLTYPE_AUTO)\
+ || defined(BOOST_NO_CXX14_DIGIT_SEPARATORS)\
+ || defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)\
+ || defined(BOOST_NO_CXX14_HDR_SHARED_MUTEX)\
+ || defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)\
+ || defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)\
+ || defined(BOOST_NO_CXX14_STD_EXCHANGE)\
+ || defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
+# define BOOST_NO_CXX14
+#endif
+
+#if defined(BOOST_NO_CXX14)\
+ || defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)\
+ || defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS)\
+ || defined(BOOST_NO_CXX17_HDR_ANY)\
+ || defined(BOOST_NO_CXX17_HDR_CHARCONV)\
+ || defined(BOOST_NO_CXX17_HDR_EXECUTION)\
+ || defined(BOOST_NO_CXX17_HDR_FILESYSTEM)\
+ || defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)\
+ || defined(BOOST_NO_CXX17_HDR_OPTIONAL)\
+ || defined(BOOST_NO_CXX17_HDR_STRING_VIEW)\
+ || defined(BOOST_NO_CXX17_HDR_VARIANT)\
+ || defined(BOOST_NO_CXX17_IF_CONSTEXPR)\
+ || defined(BOOST_NO_CXX17_INLINE_VARIABLES)\
+ || defined(BOOST_NO_CXX17_ITERATOR_TRAITS)\
+ || defined(BOOST_NO_CXX17_STD_APPLY)\
+ || defined(BOOST_NO_CXX17_STD_INVOKE)\
+ || defined(BOOST_NO_CXX17_STRUCTURED_BINDINGS)
+# define BOOST_NO_CXX17
+#endif
+
+#if defined(BOOST_NO_CXX17)\
+ || defined(BOOST_NO_CXX20_HDR_BARRIER)\
+ || defined(BOOST_NO_CXX20_HDR_BIT)\
+ || defined(BOOST_NO_CXX20_HDR_COMPARE)\
+ || defined(BOOST_NO_CXX20_HDR_CONCEPTS)\
+ || defined(BOOST_NO_CXX20_HDR_COROUTINE)\
+ || defined(BOOST_NO_CXX20_HDR_FORMAT)\
+ || defined(BOOST_NO_CXX20_HDR_LATCH)\
+ || defined(BOOST_NO_CXX20_HDR_NUMBERS)\
+ || defined(BOOST_NO_CXX20_HDR_RANGES)\
+ || defined(BOOST_NO_CXX20_HDR_SEMAPHORE)\
+ || defined(BOOST_NO_CXX20_HDR_SOURCE_LOCATION)\
+ || defined(BOOST_NO_CXX20_HDR_SPAN)\
+ || defined(BOOST_NO_CXX20_HDR_STOP_TOKEN)\
+ || defined(BOOST_NO_CXX20_HDR_SYNCSTREAM)\
+ || defined(BOOST_NO_CXX20_HDR_VERSION)
+# define BOOST_NO_CXX20
+#endif
+
// Intel
# define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp"
-#elif defined __clang__ && !defined(__ibmxl__)
+#elif defined __clang__ && !defined(__ibmxl__) && !defined(__CODEGEARC__)
// Clang C++ emulates GCC, so it has to appear early.
# define BOOST_COMPILER_CONFIG "boost/config/compiler/clang.hpp"
#elif defined(__CloudABI__)
// Nuxi CloudABI:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/cloudabi.hpp"
+
+#elif defined (__wasm__)
+// Web assembly:
+# define BOOST_PLATFORM_CONFIG "boost/config/platform/wasm.hpp"
+
#else
# if defined(unix) \
// locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed:
-// First include <cstddef> to determine if some version of STLport is in use as the std lib
+// First, check if __has_include is available and <version> include can be located,
+// otherwise include <cstddef> to determine if some version of STLport is in use as the std lib
// (do not rely on this header being included since users can short-circuit this header
// if they know whose std lib they are using.)
-#ifdef __cplusplus
+#if defined(__cplusplus) && defined(__has_include)
+# if __has_include(<version>)
+// It should be safe to include `<version>` when it is present without checking
+// the actual C++ language version as it consists solely of macro definitions.
+// [version.syn] p1: The header <version> supplies implementation-dependent
+// information about the C++ standard library (e.g., version number and release date).
+# include <version>
+# else
+# include <cstddef>
+# endif
+#elif defined(__cplusplus)
# include <cstddef>
#else
# include <stddef.h>
#endif
//
-// ensure that visibility macros are always defined, thus symplifying use
+// ensure that visibility macros are always defined, thus simplifying use
//
#ifndef BOOST_SYMBOL_EXPORT
# define BOOST_SYMBOL_EXPORT
# define BOOST_SYMBOL_VISIBLE
#endif
+//
+// disable explicitly enforced visibility
+//
+#if defined(BOOST_DISABLE_EXPLICIT_SYMBOL_VISIBILITY)
+
+#undef BOOST_SYMBOL_EXPORT
+#define BOOST_SYMBOL_EXPORT
+
+#undef BOOST_SYMBOL_IMPORT
+#define BOOST_SYMBOL_IMPORT
+
+#undef BOOST_SYMBOL_VISIBLE
+#define BOOST_SYMBOL_VISIBLE
+
+#endif
+
//
// look for long long by looking for the appropriate macros in <limits.h>.
// Note that we use limits.h rather than climits for maximal portability,
// no namespace issues from this.
//
#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG) \
- && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
+ && !defined(BOOST_MSVC) && !defined(BOOST_BORLANDC)
# include <limits.h>
# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
# define BOOST_HAS_LONG_LONG
# define BOOST_CTOR_TYPENAME
#endif
+//
+// If we're on a CUDA device (note DEVICE not HOST, irrespective of compiler) then disable __int128 and __float128 support if present:
+//
+#if defined(__CUDA_ARCH__) && defined(BOOST_HAS_FLOAT128)
+# undef BOOST_HAS_FLOAT128
+#endif
+#if defined(__CUDA_ARCH__) && defined(BOOST_HAS_INT128)
+# undef BOOST_HAS_INT128
+#endif
+
// long long workaround ------------------------------------------//
// On gcc (and maybe other compilers?) long long is alway supported
// but it's use may generate either warnings (with -ansi), or errors
# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
// When BOOST_NO_STD_TYPEINFO is defined, we can just import
-// the global definition into std namespace:
-#if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus)
+// the global definition into std namespace,
+// see https://svn.boost.org/trac10/ticket/4115
+#if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus) && defined(BOOST_MSVC)
#include <typeinfo>
namespace std{ using ::type_info; }
+// Since we do now have typeinfo, undef the macro:
+#undef BOOST_NO_STD_TYPEINFO
#endif
// ---------------------------------------------------------------------------//
// nvcc doesn't always parse __noinline__,
// see: https://svn.boost.org/trac/boost/ticket/9392
# define BOOST_NOINLINE __attribute__ ((noinline))
+# elif defined(__HIP__)
+ // See https://github.com/boostorg/config/issues/392
+# define BOOST_NOINLINE __attribute__ ((noinline))
# else
# define BOOST_NOINLINE __attribute__ ((__noinline__))
# endif
#if !defined(BOOST_NORETURN)
# if defined(_MSC_VER)
# define BOOST_NORETURN __declspec(noreturn)
-# elif defined(__GNUC__)
+# elif defined(__GNUC__) || defined(__CODEGEARC__) && defined(__clang__)
# define BOOST_NORETURN __attribute__ ((__noreturn__))
# elif defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130)
# if __has_attribute(noreturn)
# define BOOST_NORETURN
#endif
+// BOOST_DEPRECATED -------------------------------------------//
+// The macro can be used to mark deprecated symbols, such as functions, objects and types.
+// Any code that uses these symbols will produce warnings, possibly with a message specified
+// as an argument. The warnings can be suppressed by defining BOOST_ALLOW_DEPRECATED_SYMBOLS
+// or BOOST_ALLOW_DEPRECATED.
+#if !defined(BOOST_DEPRECATED) && __cplusplus >= 201402
+#define BOOST_DEPRECATED(msg) [[deprecated(msg)]]
+#endif
+
+#if defined(BOOST_ALLOW_DEPRECATED_SYMBOLS) || defined(BOOST_ALLOW_DEPRECATED)
+#undef BOOST_DEPRECATED
+#endif
+
+#if !defined(BOOST_DEPRECATED)
+#define BOOST_DEPRECATED(msg)
+#endif
+
// Branch prediction hints
// These macros are intended to wrap conditional expressions that yield true or false
//
# define BOOST_UNLIKELY(x) x
#endif
+#if !defined(BOOST_NO_CXX11_OVERRIDE)
+# define BOOST_OVERRIDE override
+#else
+# define BOOST_OVERRIDE
+#endif
+
// Type and data alignment specification
//
#if !defined(BOOST_ALIGNMENT)
#else
#define BOOST_INLINE_VARIABLE
#endif
+//
+// C++17 if constexpr
+//
+#if !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
+# define BOOST_IF_CONSTEXPR if constexpr
+#else
+# define BOOST_IF_CONSTEXPR if
+#endif
+
+#define BOOST_INLINE_CONSTEXPR BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST
//
// Unused variable/typedef workarounds:
//
// [[nodiscard]]:
//
-#ifdef __has_cpp_attribute
+#if defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130)
+#if __has_attribute(nodiscard)
+# define BOOST_ATTRIBUTE_NODISCARD [[nodiscard]]
+#endif
+#if __has_attribute(no_unique_address)
+# define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#endif
+#elif defined(__has_cpp_attribute)
// clang-6 accepts [[nodiscard]] with -std=c++14, but warns about it -pedantic
-#if __has_cpp_attribute(nodiscard) && !(defined(__clang__) && (__cplusplus < 201703L))
+#if __has_cpp_attribute(nodiscard) && !(defined(__clang__) && (__cplusplus < 201703L)) && !(defined(__GNUC__) && (__cplusplus < 201100))
# define BOOST_ATTRIBUTE_NODISCARD [[nodiscard]]
#endif
#if __has_cpp_attribute(no_unique_address) && !(defined(__GNUC__) && (__cplusplus < 201100))
#define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+# define BOOST_NULLPTR nullptr
+#else
+# define BOOST_NULLPTR 0
+#endif
+
//
// Set BOOST_HAS_STATIC_ASSERT when BOOST_NO_CXX11_STATIC_ASSERT is not defined
//
# define BOOST_NO_CXX17_HDR_OPTIONAL
# define BOOST_NO_CXX17_HDR_STRING_VIEW
# define BOOST_NO_CXX17_HDR_VARIANT
+# define BOOST_NO_CXX17_HDR_ANY
+# define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+# define BOOST_NO_CXX17_HDR_CHARCONV
+# define BOOST_NO_CXX17_HDR_EXECUTION
+# define BOOST_NO_CXX17_HDR_FILESYSTEM
#else
#if !__has_include(<optional>)
# define BOOST_NO_CXX17_HDR_OPTIONAL
#if !__has_include(<variant>)
# define BOOST_NO_CXX17_HDR_VARIANT
#endif
+#if !__has_include(<any>)
+# define BOOST_NO_CXX17_HDR_ANY
#endif
+#if !__has_include(<memory_resource>)
+# define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
#endif
+#if !__has_include(<charconv>)
+# define BOOST_NO_CXX17_HDR_CHARCONV
+#endif
+#if !__has_include(<execution>)
+# define BOOST_NO_CXX17_HDR_EXECUTION
+#endif
+#if !__has_include(<filesystem>)
+# define BOOST_NO_CXX17_HDR_FILESYSTEM
+#endif
+#endif
+#endif
+//
+// Define the std level that the compiler claims to support:
+//
+#ifndef BOOST_CXX_VERSION
+# define BOOST_CXX_VERSION __cplusplus
+#endif
+
+#if (!defined(__has_include) || (BOOST_CXX_VERSION < 201704))
+# define BOOST_NO_CXX20_HDR_BARRIER
+# define BOOST_NO_CXX20_HDR_FORMAT
+# define BOOST_NO_CXX20_HDR_SOURCE_LOCATION
+# define BOOST_NO_CXX20_HDR_BIT
+# define BOOST_NO_CXX20_HDR_LATCH
+# define BOOST_NO_CXX20_HDR_SPAN
+# define BOOST_NO_CXX20_HDR_COMPARE
+# define BOOST_NO_CXX20_HDR_NUMBERS
+# define BOOST_NO_CXX20_HDR_STOP_TOKEN
+# define BOOST_NO_CXX20_HDR_CONCEPTS
+# define BOOST_NO_CXX20_HDR_RANGES
+# define BOOST_NO_CXX20_HDR_SYNCSTREAM
+# define BOOST_NO_CXX20_HDR_COROUTINE
+# define BOOST_NO_CXX20_HDR_SEMAPHORE
+#else
+#if (!__has_include(<barrier>) || !defined(__cpp_lib_barrier) || (__cpp_lib_barrier < 201907L)) && !defined(BOOST_NO_CXX20_HDR_BARRIER)
+# define BOOST_NO_CXX20_HDR_BARRIER
+#endif
+#if (!__has_include(<format>) || !defined(__cpp_lib_format) || (__cpp_lib_format < 201907L)) && !defined(BOOST_NO_CXX20_HDR_FORMAT)
+# define BOOST_NO_CXX20_HDR_FORMAT
+#endif
+#if (!__has_include(<source_location>) || !defined(__cpp_lib_source_location) || (__cpp_lib_source_location < 201907L)) && !defined(BOOST_NO_CXX20_HDR_SOURCE_LOCATION)
+# define BOOST_NO_CXX20_HDR_SOURCE_LOCATION
+#endif
+#if (!__has_include(<bit>) || !defined(__cpp_lib_bit_cast) || (__cpp_lib_bit_cast < 201806L) || !defined(__cpp_lib_bitops) || (__cpp_lib_bitops < 201907L) || !defined(__cpp_lib_endian) || (__cpp_lib_endian < 201907L)) && !defined(BOOST_NO_CXX20_HDR_BIT)
+# define BOOST_NO_CXX20_HDR_BIT
+#endif
+#if (!__has_include(<latch>) || !defined(__cpp_lib_latch) || (__cpp_lib_latch < 201907L)) && !defined(BOOST_NO_CXX20_HDR_LATCH)
+# define BOOST_NO_CXX20_HDR_LATCH
+#endif
+#if (!__has_include(<span>) || !defined(__cpp_lib_span) || (__cpp_lib_span < 202002L)) && !defined(BOOST_NO_CXX20_HDR_SPAN)
+# define BOOST_NO_CXX20_HDR_SPAN
+#endif
+#if (!__has_include(<compare>) || !defined(__cpp_lib_three_way_comparison) || (__cpp_lib_three_way_comparison < 201907L)) && !defined(BOOST_NO_CXX20_HDR_COMPARE)
+# define BOOST_NO_CXX20_HDR_COMPARE
+#endif
+#if (!__has_include(<numbers>) || !defined(__cpp_lib_math_constants) || (__cpp_lib_math_constants < 201907L)) && !defined(BOOST_NO_CXX20_HDR_NUMBERS)
+# define BOOST_NO_CXX20_HDR_NUMBERS
+#endif
+#if (!__has_include(<stop_token>) || !defined(__cpp_lib_jthread) || (__cpp_lib_jthread < 201911L)) && !defined(BOOST_NO_CXX20_HDR_STOP_TOKEN)
+# define BOOST_NO_CXX20_HDR_STOP_TOKEN
+#endif
+#if (!__has_include(<concepts>) || !defined(__cpp_lib_concepts) || (__cpp_lib_concepts < 202002L)) && !defined(_YVALS) && !defined(_CPPLIB_VER) && !defined(BOOST_NO_CXX20_HDR_CONCEPTS)
+# define BOOST_NO_CXX20_HDR_CONCEPTS
+#endif
+#if (!__has_include(<ranges>) || !defined(__cpp_lib_ranges) || (__cpp_lib_ranges < 201911L)) && !defined(BOOST_NO_CXX20_HDR_RANGES)
+# define BOOST_NO_CXX20_HDR_RANGES
+#endif
+#if (!__has_include(<syncstream>) || !defined(__cpp_lib_syncbuf) || (__cpp_lib_syncbuf < 201803L)) && !defined(BOOST_NO_CXX20_HDR_SYNCSTREAM)
+# define BOOST_NO_CXX20_HDR_SYNCSTREAM
+#endif
+#if (!__has_include(<coroutine>) || !defined(__cpp_lib_coroutine) || (__cpp_lib_coroutine < 201902L)) && !defined(BOOST_NO_CXX20_HDR_COROUTINE)
+# define BOOST_NO_CXX20_HDR_COROUTINE
+#endif
+#if (!__has_include(<semaphore>) || !defined(__cpp_lib_semaphore) || (__cpp_lib_semaphore < 201907L)) && !defined(BOOST_NO_CXX20_HDR_SEMAPHORE)
+# define BOOST_NO_CXX20_HDR_SEMAPHORE
+#endif
+#endif
+
+#if defined(__cplusplus) && defined(__has_include)
+#if !__has_include(<version>)
+# define BOOST_NO_CXX20_HDR_VERSION
+#else
+// For convenience, this is always included:
+# include <version>
+#endif
+#else
+# define BOOST_NO_CXX20_HDR_VERSION
+#endif
+
+#if defined(BOOST_MSVC)
+#if (BOOST_MSVC < 1914) || (_MSVC_LANG < 201703)
+# define BOOST_NO_CXX17_DEDUCTION_GUIDES
+#endif
+#elif !defined(__cpp_deduction_guides) || (__cpp_deduction_guides < 201606)
+# define BOOST_NO_CXX17_DEDUCTION_GUIDES
+#endif
+
+//
+// Define composite agregate macros:
+//
+#include <boost/config/detail/cxx_composite.hpp>
//
// Finish off with checks for macros that are depricated / no longer supported,
#include <boost/config/pragma_message.hpp>
-#if defined(BOOST_ALLOW_DEPRECATED_HEADERS)
+#if defined(BOOST_ALLOW_DEPRECATED_HEADERS) || defined(BOOST_ALLOW_DEPRECATED)
# define BOOST_HEADER_DEPRECATED(a)
#else
# define BOOST_HEADER_DEPRECATED(a) BOOST_PRAGMA_MESSAGE("This header is deprecated. Use " a " instead.")
// FreeBSD has <nl_types.h> but does not
// advertise the fact in <unistd.h>:
//
-#if (defined(__FreeBSD__) && (__FreeBSD__ >= 3)) || defined(__DragonFly__)
+#if (defined(__FreeBSD__) && (__FreeBSD__ >= 3)) \
+ || defined(__OpenBSD__) || defined(__DragonFly__)
# define BOOST_HAS_NL_TYPES_H
#endif
#endif
#if !((defined(__FreeBSD__) && (__FreeBSD__ >= 5)) \
- || (defined(__NetBSD_GCC__) && (__NetBSD_GCC__ >= 2095003)) || defined(__DragonFly__))
+ || (defined(__NetBSD_GCC__) && (__NetBSD_GCC__ >= 2095003)) \
+ || defined(__OpenBSD__) || defined(__DragonFly__))
# define BOOST_NO_CWCHAR
#endif
//
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#define BOOST_HAS_SIGACTION
+#define BOOST_HAS_CLOCK_GETTIME
// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/detail/posix_features.hpp>
-
-
-
-
-
-
--- /dev/null
+// (C) Copyright John Maddock 2020.
+// 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 for most recent version.
+
+// WASM specific config options:
+
+#define BOOST_PLATFORM "Wasm"
+
+#ifdef __has_include
+#if __has_include(<unistd.h>)
+# define BOOST_HAS_UNISTD_H
+#endif
+#endif
+
+// boilerplate code:
+#include <boost/config/detail/posix_features.hpp>
+//
+// fenv lacks the C++11 macros:
+//
+#define BOOST_NO_FENV_H
// Compaq Tru64 Unix cxx
# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread"
-#elif defined __BORLANDC__
+#elif defined BOOST_BORLANDC
// Borland
# error "Compiler threading support is not turned on. Please set the correct command line options for threading: -tWM"
#if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306)
// full dinkumware 3.06 and above
// fully conforming provided the compiler supports it:
-# if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(__BORLANDC__) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700)) // can be defined in yvals.h
+# if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(BOOST_BORLANDC) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700)) // can be defined in yvals.h
# define BOOST_NO_STDC_NAMESPACE
# endif
# if !(defined(_HAS_MEMBER_TEMPLATES_REBIND) && (_HAS_MEMBER_TEMPLATES_REBIND+0 > 0)) && !(defined(_MSC_VER) && (_MSC_VER > 1300)) && defined(BOOST_MSVC)
// the same applies to other compilers that sit on top
// of vc7.1 (Intel and Comeau):
//
-#if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(__BORLANDC__)
+#if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(BOOST_BORLANDC)
# define BOOST_STD_EXTENSION_NAMESPACE stdext
#endif
-#if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(__BORLANDC__)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306)
+#if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(BOOST_BORLANDC)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306)
// if we're using a dinkum lib that's
// been configured for VC6/7 then there is
// no iterator traits (true even for icl)
# define BOOST_NO_STD_LOCALE
#endif
+#if ((defined(BOOST_MSVC) && BOOST_MSVC >= 1400) || (defined(__clang__) && defined(_MSC_VER))) && (_MSC_VER < 1800)
// Fix for VC++ 8.0 on up ( I do not have a previous version to test )
// or clang-cl. If exceptions are off you must manually include the
// <exception> header before including the <typeinfo> header. Admittedly
// trying to use Boost libraries or the standard C++ libraries without
// exception support is not suggested but currently clang-cl ( v 3.4 )
// does not support exceptions and must be compiled with exceptions off.
-#if !_HAS_EXCEPTIONS && ((defined(BOOST_MSVC) && BOOST_MSVC >= 1400) || (defined(__clang__) && defined(_MSC_VER)))
+#if !_HAS_EXCEPTIONS
#include <exception>
#endif
#include <typeinfo>
-#if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (defined(__ghs__) && !_HAS_NAMESPACE) ) && !defined(__TI_COMPILER_VERSION__) && !defined(__VISUALDSPVERSION__) \
- && !defined(__VXWORKS__)
+#if !_HAS_EXCEPTIONS
# define BOOST_NO_STD_TYPEINFO
#endif
+#endif
+#if defined(__ghs__) && !_HAS_NAMESPACE
+# define BOOST_NO_STD_TYPEINFO
+#endif
// C++0x headers implemented in 520 (as shipped by Microsoft)
//
#endif
// C++17 features
-#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) || !defined(BOOST_MSVC) || (BOOST_MSVC < 1910) || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0)
+#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) \
+ || ((!defined(BOOST_MSVC) || (BOOST_MSVC < 1910))) && (!defined(__clang__) || !defined(_MSC_VER) || (_MSC_VER < 1929))\
+ || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0)
# define BOOST_NO_CXX17_STD_APPLY
# define BOOST_NO_CXX17_ITERATOR_TRAITS
# define BOOST_NO_CXX17_HDR_STRING_VIEW
# define BOOST_NO_CXX17_HDR_OPTIONAL
# define BOOST_NO_CXX17_HDR_VARIANT
+# define BOOST_NO_CXX17_HDR_ANY
+# define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+# define BOOST_NO_CXX17_HDR_CHARCONV
+# define BOOST_NO_CXX17_HDR_EXECUTION
+# define BOOST_NO_CXX17_HDR_FILESYSTEM
#endif
#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0) || !defined(_MSVC_STL_UPDATE) || (_MSVC_STL_UPDATE < 201709)
# define BOOST_NO_CXX17_STD_INVOKE
#endif
+// C++20 features which aren't configured in suffix.hpp correctly:
+#if !defined(_MSVC_STL_UPDATE) || (_MSVC_STL_UPDATE < 202008L) || !defined(_HAS_CXX20) || (_HAS_CXX20 == 0)
+# define BOOST_NO_CXX20_HDR_CONCEPTS
+#endif
+
#if !(!defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) || !defined(BOOST_MSVC) || (BOOST_MSVC < 1912) || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0))
// Deprecated std::iterator:
# define BOOST_NO_STD_ITERATOR
// Bug specific to VC14,
// See https://connect.microsoft.com/VisualStudio/feedback/details/1348277/link-error-when-using-std-codecvt-utf8-utf16-char16-t
// and discussion here: http://blogs.msdn.com/b/vcblog/archive/2014/11/12/visual-studio-2015-preview-now-available.aspx?PageIndex=2
-#if defined(_CPPLIB_VER) && (_CPPLIB_VER == 650)
+#if defined(_CPPLIB_VER) && (_CPPLIB_VER == 650) && (!defined(_MSVC_STL_VERSION) || (_MSVC_STL_VERSION < 142))
+# define BOOST_NO_CXX11_HDR_CODECVT
+#endif
+
+#if (_MSVC_LANG > 201700) && !defined(BOOST_NO_CXX11_HDR_CODECVT)
+//
+// <codecvt> is deprected as of C++17, and by default MSVC emits hard errors
+// if you try to use it, so mark it as unavailable:
+//
# define BOOST_NO_CXX11_HDR_CODECVT
#endif
# define BOOST_NO_CXX98_BINDERS
# endif
#endif
+//
+// Things deprecated in C++20:
+//
+#if defined(_HAS_CXX20)
+# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#endif
//
# define BOOST_NO_CXX98_BINDERS
#endif
-#define BOOST_NO_CXX17_ITERATOR_TRAITS
+#if defined(__cplusplus) && defined(__has_include)
+#if __has_include(<version>)
+#include <version>
+
+#if !defined(__cpp_lib_execution) || (__cpp_lib_execution < 201603L)
+# define BOOST_NO_CXX17_HDR_EXECUTION
+#endif
+#if !defined(__cpp_lib_invoke) || (__cpp_lib_invoke < 201411L)
+#define BOOST_NO_CXX17_STD_INVOKE
+#endif
+
+#if(_LIBCPP_VERSION < 9000)
+// as_writable_bytes is missing.
+# define BOOST_NO_CXX20_HDR_SPAN
+#endif
+
+#else
+#define BOOST_NO_CXX17_STD_INVOKE // Invoke support is incomplete (no invoke_result)
+#define BOOST_NO_CXX17_HDR_EXECUTION
+#endif
+#else
#define BOOST_NO_CXX17_STD_INVOKE // Invoke support is incomplete (no invoke_result)
+#define BOOST_NO_CXX17_HDR_EXECUTION
+#endif
+
+#if _LIBCPP_VERSION < 10000 // What's the correct version check here?
+#define BOOST_NO_CXX17_ITERATOR_TRAITS
+#endif
#if (_LIBCPP_VERSION <= 1101) && !defined(BOOST_NO_CXX11_THREAD_LOCAL)
// This is a bit of a sledgehammer, because really it's just libc++abi that has no
# define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
+#if _LIBCPP_VERSION >= 15000
+//
+// Unary function is now deprecated in C++11 and later:
+//
+#if __cplusplus >= 201103L
+#define BOOST_NO_CXX98_FUNCTION_BASE
+#endif
+#endif
+
// --- end ---
#endif
#endif
+#if defined(__has_include)
+#if defined(BOOST_HAS_HASH)
+#if !__has_include(BOOST_HASH_SET_HEADER) || (__GNUC__ >= 10)
+#undef BOOST_HAS_HASH
+#undef BOOST_HAS_SET_HEADER
+#undef BOOST_HAS_MAP_HEADER
+#endif
+#if !__has_include(BOOST_SLIST_HEADER)
+#undef BOOST_HAS_SLIST
+#undef BOOST_HAS_SLIST_HEADER
+#endif
+#endif
+#endif
+
//
// Decide whether we have C++11 support turned on:
//
//
#ifdef __clang__
-#if __has_include(<memory_resource>)
+#if __has_include(<expected>)
+# define BOOST_LIBSTDCXX_VERSION 120100
+#elif __has_include(<source_location>)
+# define BOOST_LIBSTDCXX_VERSION 110100
+#elif __has_include(<compare>)
+# define BOOST_LIBSTDCXX_VERSION 100100
+#elif __has_include(<memory_resource>)
# define BOOST_LIBSTDCXX_VERSION 90100
#elif __has_include(<charconv>)
# define BOOST_LIBSTDCXX_VERSION 80100
#elif __has_include(<array>)
# define BOOST_LIBSTDCXX_VERSION 40300
#endif
+//
+// If BOOST_HAS_FLOAT128 is set, now that we know the std lib is libstdc++3, check to see if the std lib is
+// configured to support this type. If not disable it:
+//
+#if defined(BOOST_HAS_FLOAT128) && !defined(_GLIBCXX_USE_FLOAT128)
+# undef BOOST_HAS_FLOAT128
+#endif
+
+#if (BOOST_LIBSTDCXX_VERSION >= 100000) && defined(BOOST_HAS_HASH)
+//
+// hash_set/hash_map deprecated and have terminal bugs:
+//
+#undef BOOST_HAS_HASH
+#undef BOOST_HAS_SET_HEADER
+#undef BOOST_HAS_MAP_HEADER
+#endif
+
+
+#if (BOOST_LIBSTDCXX_VERSION >= 100000) && defined(BOOST_HAS_HASH)
+//
+// hash_set/hash_map deprecated and have terminal bugs:
+//
+#undef BOOST_HAS_HASH
+#undef BOOST_HAS_SET_HEADER
+#undef BOOST_HAS_MAP_HEADER
+#endif
+
#if (BOOST_LIBSTDCXX_VERSION < 50100)
// libstdc++ does not define this function as it's deprecated in C++11, but clang still looks for it,
# endif
# elif !_GLIBCXX_USE_DEPRECATED
# define BOOST_NO_AUTO_PTR
+# define BOOST_NO_CXX98_BINDERS
# endif
#endif
# define BOOST_NO_CXX14_STD_EXCHANGE
#endif
-#if defined(__clang_major__) && ((__clang_major__ < 3) || ((__clang_major__ == 3) && (__clang_minor__ < 7)))
-// As of clang-3.6, libstdc++ header <atomic> throws up errors with clang:
-# define BOOST_NO_CXX11_HDR_ATOMIC
-#endif
//
// C++0x features in GCC 5.1 and later
//
#elif __cplusplus <= 201103
# define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
+//
+// <execution> has a dependency to Intel's thread building blocks:
+// unless these are installed seperately, including <execution> leads
+// to inscrutable errors inside libstdc++'s own headers.
+//
+#if (BOOST_LIBSTDCXX_VERSION < 100100)
+#if !__has_include(<tbb/tbb.h>)
+#define BOOST_NO_CXX17_HDR_EXECUTION
+#endif
+#endif
#elif __cplusplus < 201402 || (BOOST_LIBSTDCXX_VERSION < 40900) || !defined(BOOST_LIBSTDCXX11)
# define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
+#if BOOST_LIBSTDCXX_VERSION < 100100
+//
+// The header may be present but is incomplete:
+//
+# define BOOST_NO_CXX17_HDR_CHARCONV
+#endif
+
+#if BOOST_LIBSTDCXX_VERSION < 110000
+//
+// Header <bit> may be present but lacks std::bit_cast:
+//
+#define BOOST_NO_CXX20_HDR_BIT
+#endif
+
+#if BOOST_LIBSTDCXX_VERSION >= 120000
+//
+// Unary function is now deprecated in C++11 and later:
+//
+#if __cplusplus >= 201103L
+#define BOOST_NO_CXX98_FUNCTION_BASE
+#endif
+#endif
+
+#ifndef __cpp_impl_coroutine
+# define BOOST_NO_CXX20_HDR_COROUTINE
+#endif
+
+//
+// These next defines are mostly for older clang versions with a newer libstdc++ :
+//
+#if !defined(__cpp_lib_concepts)
+#if !defined(BOOST_NO_CXX20_HDR_COMPARE)
+# define BOOST_NO_CXX20_HDR_COMPARE
+#endif
+#if !defined(BOOST_NO_CXX20_HDR_CONCEPTS)
+# define BOOST_NO_CXX20_HDR_CONCEPTS
+#endif
+#if !defined(BOOST_NO_CXX20_HDR_SPAN)
+# define BOOST_NO_CXX20_HDR_SPAN
+#endif
+#if !defined(BOOST_NO_CXX20_HDR_RANGES)
+# define BOOST_NO_CXX20_HDR_RANGES
+#endif
+#endif
+
+#if defined(__clang__)
+#if (__clang_major__ < 11) && !defined(BOOST_NO_CXX20_HDR_RANGES)
+# define BOOST_NO_CXX20_HDR_RANGES
+#endif
+#if (__clang_major__ < 10) && (BOOST_LIBSTDCXX_VERSION >= 110000) && !defined(BOOST_NO_CXX11_HDR_CHRONO)
+// Old clang can't parse <chrono>:
+# define BOOST_NO_CXX11_HDR_CHRONO
+# define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#endif
+#endif
+
//
// Headers not present on Solaris with the Oracle compiler:
#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5140)
# endif
#endif
-#if (!defined(_GTHREAD_USE_MUTEX_TIMEDLOCK) || (_GTHREAD_USE_MUTEX_TIMEDLOCK == 0)) && !defined(BOOST_NO_CXX11_HDR_MUTEX)
+#if (!defined(_GTHREAD_USE_MUTEX_TIMEDLOCK) || (_GTHREAD_USE_MUTEX_TIMEDLOCK == 0)) && !defined(BOOST_NO_CXX11_HDR_MUTEX) && (__GNUC__ < 6)
// Timed mutexes are not always available:
# define BOOST_NO_CXX11_HDR_MUTEX
#endif
//
// Borland version of numeric_limits lacks __int64 specialisation:
//
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
# define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#endif
// then the io stream facets are not available in namespace std::
//
#ifdef _STLPORT_VERSION
-# if !(_STLPORT_VERSION >= 0x500) && !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__)
+# if !(_STLPORT_VERSION >= 0x500) && !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(BOOST_BORLANDC)
# define BOOST_NO_STD_LOCALE
# endif
#else
-# if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__)
+# if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(BOOST_BORLANDC)
# define BOOST_NO_STD_LOCALE
# endif
#endif
// BCB6 does cause problems. If we detect C++ Builder, then don't define
// BOOST_NO_STDC_NAMESPACE
//
-#if !defined(__BORLANDC__) && !defined(__DMC__)
+#if !defined(BOOST_BORLANDC) && !defined(__DMC__)
//
// If STLport is using it's own namespace, and the real names are in
// the global namespace, then we duplicate STLport's using declarations
# define BOOST_NO_STDC_NAMESPACE
# define BOOST_NO_EXCEPTION_STD_NAMESPACE
# endif
-#elif defined(__BORLANDC__) && __BORLANDC__ < 0x560
+#elif defined(BOOST_BORLANDC) && BOOST_BORLANDC < 0x560
// STLport doesn't import std::abs correctly:
#include <stdlib.h>
namespace std { using ::abs; }
// Borland ships a version of STLport with C++ Builder 6 that lacks
// hashtables and the like:
//
-#if defined(__BORLANDC__) && (__BORLANDC__ == 0x560)
+#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC == 0x560)
# undef BOOST_HAS_HASH
#endif
#else
#define __CODEGEARC___WORKAROUND_GUARD 0
#endif
+#ifndef BOOST_BORLANDC
+#define BOOST_BORLANDC_WORKAROUND_GUARD 1
+#else
+#define BOOST_BORLANDC_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_CODEGEARC
+#define BOOST_CODEGEARC_WORKAROUND_GUARD 1
+#else
+#define BOOST_CODEGEARC_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_EMBTC
+#define BOOST_EMBTC_WORKAROUND_GUARD 1
+#else
+#define BOOST_EMBTC_WORKAROUND_GUARD 0
+#endif
#ifndef _MSC_VER
#define _MSC_VER_WORKAROUND_GUARD 1
#else
#else
#define _COMPILER_VERSION_WORKAROUND_GUARD 0
#endif
+#ifndef __clang_major__
+#define __clang_major___WORKAROUND_GUARD 1
+#else
+#define __clang_major___WORKAROUND_GUARD 0
+#endif
#ifndef _RWSTD_VER
#define _RWSTD_VER_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_WORKAROUND_GUARD 0
#endif
+#ifndef BOOST_CLANG_VERSION
+#define BOOST_CLANG_VERSION_WORKAROUND_GUARD 1
+#else
+#define BOOST_CLANG_VERSION_WORKAROUND_GUARD 0
+#endif
+
// Always define to zero, if it's used it'll be defined my MPL:
#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
+++ /dev/null
-
-// Copyright 2005-2009 Daniel James.
-// 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)
-
-#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP)
-#define BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#include <boost/config/no_tr1/cmath.hpp>
-
-// Set BOOST_HASH_CONFORMANT_FLOATS to 1 for libraries known to have
-// sufficiently good floating point support to not require any
-// workarounds.
-//
-// When set to 0, the library tries to automatically
-// use the best available implementation. This normally works well, but
-// breaks when ambiguities are created by odd namespacing of the functions.
-//
-// Note that if this is set to 0, the library should still take full
-// advantage of the platform's floating point support.
-
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(__LIBCOMO__)
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
-// Rogue Wave library:
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(_LIBCPP_VERSION)
-// libc++
-# define BOOST_HASH_CONFORMANT_FLOATS 1
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-// GNU libstdc++ 3
-# if defined(__GNUC__) && __GNUC__ >= 4
-# define BOOST_HASH_CONFORMANT_FLOATS 1
-# else
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-# endif
-#elif defined(__STL_CONFIG_H)
-// generic SGI STL
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(__MSL_CPP__)
-// MSL standard lib:
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif defined(__IBMCPP__)
-// VACPP std lib (probably conformant for much earlier version).
-# if __IBMCPP__ >= 1210
-# define BOOST_HASH_CONFORMANT_FLOATS 1
-# else
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-# endif
-#elif defined(MSIPL_COMPILE_H)
-// Modena C++ standard library
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
-// Dinkumware Library (this has to appear after any possible replacement libraries):
-# if _CPPLIB_VER >= 405
-# define BOOST_HASH_CONFORMANT_FLOATS 1
-# else
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-# endif
-#else
-# define BOOST_HASH_CONFORMANT_FLOATS 0
-#endif
-
-#if BOOST_HASH_CONFORMANT_FLOATS
-
-// The standard library is known to be compliant, so don't use the
-// configuration mechanism.
-
-namespace boost {
- namespace hash_detail {
- template <typename Float>
- struct call_ldexp {
- typedef Float float_type;
- inline Float operator()(Float x, int y) const {
- return std::ldexp(x, y);
- }
- };
-
- template <typename Float>
- struct call_frexp {
- typedef Float float_type;
- inline Float operator()(Float x, int* y) const {
- return std::frexp(x, y);
- }
- };
-
- template <typename Float>
- struct select_hash_type
- {
- typedef Float type;
- };
- }
-}
-
-#else // BOOST_HASH_CONFORMANT_FLOATS == 0
-
-// The C++ standard requires that the C float functions are overloarded
-// for float, double and long double in the std namespace, but some of the older
-// library implementations don't support this. On some that don't, the C99
-// float functions (frexpf, frexpl, etc.) are available.
-//
-// The following tries to automatically detect which are available.
-
-namespace boost {
- namespace hash_detail {
-
- // Returned by dummy versions of the float functions.
-
- struct not_found {
- // Implicitly convertible to float and long double in order to avoid
- // a compile error when the dummy float functions are used.
-
- inline operator float() const { return 0; }
- inline operator long double() const { return 0; }
- };
-
- // A type for detecting the return type of functions.
-
- template <typename T> struct is;
- template <> struct is<float> { char x[10]; };
- template <> struct is<double> { char x[20]; };
- template <> struct is<long double> { char x[30]; };
- template <> struct is<boost::hash_detail::not_found> { char x[40]; };
-
- // Used to convert the return type of a function to a type for sizeof.
-
- template <typename T> is<T> float_type(T);
-
- // call_ldexp
- //
- // This will get specialized for float and long double
-
- template <typename Float> struct call_ldexp
- {
- typedef double float_type;
-
- inline double operator()(double a, int b) const
- {
- using namespace std;
- return ldexp(a, b);
- }
- };
-
- // call_frexp
- //
- // This will get specialized for float and long double
-
- template <typename Float> struct call_frexp
- {
- typedef double float_type;
-
- inline double operator()(double a, int* b) const
- {
- using namespace std;
- return frexp(a, b);
- }
- };
- }
-}
-
-// A namespace for dummy functions to detect when the actual function we want
-// isn't available. ldexpl, ldexpf etc. might be added tby the macros below.
-//
-// AFAICT these have to be outside of the boost namespace, as if they're in
-// the boost namespace they'll always be preferable to any other function
-// (since the arguments are built in types, ADL can't be used).
-
-namespace boost_hash_detect_float_functions {
- template <class Float> boost::hash_detail::not_found ldexp(Float, int);
- template <class Float> boost::hash_detail::not_found frexp(Float, int*);
-}
-
-// Macros for generating specializations of call_ldexp and call_frexp.
-//
-// check_cpp and check_c99 check if the C++ or C99 functions are available.
-//
-// Then the call_* functions select an appropriate implementation.
-//
-// I used c99_func in a few places just to get a unique name.
-//
-// Important: when using 'using namespace' at namespace level, include as
-// little as possible in that namespace, as Visual C++ has an odd bug which
-// can cause the namespace to be imported at the global level. This seems to
-// happen mainly when there's a template in the same namesapce.
-
-#define BOOST_HASH_CALL_FLOAT_FUNC(cpp_func, c99_func, type1, type2) \
-namespace boost_hash_detect_float_functions { \
- template <class Float> \
- boost::hash_detail::not_found c99_func(Float, type2); \
-} \
- \
-namespace boost { \
- namespace hash_detail { \
- namespace c99_func##_detect { \
- using namespace std; \
- using namespace boost_hash_detect_float_functions; \
- \
- struct check { \
- static type1 x; \
- static type2 y; \
- BOOST_STATIC_CONSTANT(bool, cpp = \
- sizeof(float_type(cpp_func(x,y))) \
- == sizeof(is<type1>)); \
- BOOST_STATIC_CONSTANT(bool, c99 = \
- sizeof(float_type(c99_func(x,y))) \
- == sizeof(is<type1>)); \
- }; \
- } \
- \
- template <bool x> \
- struct call_c99_##c99_func : \
- boost::hash_detail::call_##cpp_func<double> {}; \
- \
- template <> \
- struct call_c99_##c99_func<true> { \
- typedef type1 float_type; \
- \
- template <typename T> \
- inline type1 operator()(type1 a, T b) const \
- { \
- using namespace std; \
- return c99_func(a, b); \
- } \
- }; \
- \
- template <bool x> \
- struct call_cpp_##c99_func : \
- call_c99_##c99_func< \
- ::boost::hash_detail::c99_func##_detect::check::c99 \
- > {}; \
- \
- template <> \
- struct call_cpp_##c99_func<true> { \
- typedef type1 float_type; \
- \
- template <typename T> \
- inline type1 operator()(type1 a, T b) const \
- { \
- using namespace std; \
- return cpp_func(a, b); \
- } \
- }; \
- \
- template <> \
- struct call_##cpp_func<type1> : \
- call_cpp_##c99_func< \
- ::boost::hash_detail::c99_func##_detect::check::cpp \
- > {}; \
- } \
-}
-
-#define BOOST_HASH_CALL_FLOAT_MACRO(cpp_func, c99_func, type1, type2) \
-namespace boost { \
- namespace hash_detail { \
- \
- template <> \
- struct call_##cpp_func<type1> { \
- typedef type1 float_type; \
- inline type1 operator()(type1 x, type2 y) const { \
- return c99_func(x, y); \
- } \
- }; \
- } \
-}
-
-#if defined(ldexpf)
-BOOST_HASH_CALL_FLOAT_MACRO(ldexp, ldexpf, float, int)
-#else
-BOOST_HASH_CALL_FLOAT_FUNC(ldexp, ldexpf, float, int)
-#endif
-
-#if defined(ldexpl)
-BOOST_HASH_CALL_FLOAT_MACRO(ldexp, ldexpl, long double, int)
-#else
-BOOST_HASH_CALL_FLOAT_FUNC(ldexp, ldexpl, long double, int)
-#endif
-
-#if defined(frexpf)
-BOOST_HASH_CALL_FLOAT_MACRO(frexp, frexpf, float, int*)
-#else
-BOOST_HASH_CALL_FLOAT_FUNC(frexp, frexpf, float, int*)
-#endif
-
-#if defined(frexpl)
-BOOST_HASH_CALL_FLOAT_MACRO(frexp, frexpl, long double, int*)
-#else
-BOOST_HASH_CALL_FLOAT_FUNC(frexp, frexpl, long double, int*)
-#endif
-
-#undef BOOST_HASH_CALL_FLOAT_MACRO
-#undef BOOST_HASH_CALL_FLOAT_FUNC
-
-
-namespace boost
-{
- namespace hash_detail
- {
- template <typename Float1, typename Float2>
- struct select_hash_type_impl {
- typedef double type;
- };
-
- template <>
- struct select_hash_type_impl<float, float> {
- typedef float type;
- };
-
- template <>
- struct select_hash_type_impl<long double, long double> {
- typedef long double type;
- };
-
-
- // select_hash_type
- //
- // If there is support for a particular floating point type, use that
- // otherwise use double (there's always support for double).
-
- template <typename Float>
- struct select_hash_type : select_hash_type_impl<
- BOOST_DEDUCED_TYPENAME call_ldexp<Float>::float_type,
- BOOST_DEDUCED_TYPENAME call_frexp<Float>::float_type
- > {};
- }
-}
-
-#endif // BOOST_HASH_CONFORMANT_FLOATS
-
-#endif
+++ /dev/null
-
-// Copyright 2005-2012 Daniel James.
-// 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)
-
-#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER)
-#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#include <boost/container_hash/detail/float_functions.hpp>
-#include <boost/container_hash/detail/limits.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/integer/static_log2.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <cstring>
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#if BOOST_MSVC >= 1400
-#pragma warning(disable:6294) // Ill-defined for-loop: initial condition does
- // not satisfy test. Loop body not executed
-#endif
-#endif
-
-// Can we use fpclassify?
-
-// STLport
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define BOOST_HASH_USE_FPCLASSIFY 0
-
-// GNU libstdc++ 3
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-# if (defined(__USE_ISOC99) || defined(_GLIBCXX_USE_C99_MATH)) && \
- !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
-# define BOOST_HASH_USE_FPCLASSIFY 1
-# else
-# define BOOST_HASH_USE_FPCLASSIFY 0
-# endif
-
-// Everything else
-#else
-# define BOOST_HASH_USE_FPCLASSIFY 0
-#endif
-
-namespace boost
-{
- namespace hash_detail
- {
- inline void hash_float_combine(std::size_t& seed, std::size_t value)
- {
- seed ^= value + (seed<<6) + (seed>>2);
- }
-
- ////////////////////////////////////////////////////////////////////////
- // Binary hash function
- //
- // Only used for floats with known iec559 floats, and certain values in
- // numeric_limits
-
- inline std::size_t hash_binary(char* ptr, std::size_t length)
- {
- std::size_t seed = 0;
-
- if (length >= sizeof(std::size_t)) {
- std::memcpy(&seed, ptr, sizeof(std::size_t));
- length -= sizeof(std::size_t);
- ptr += sizeof(std::size_t);
-
- while(length >= sizeof(std::size_t)) {
- std::size_t buffer = 0;
- std::memcpy(&buffer, ptr, sizeof(std::size_t));
- hash_float_combine(seed, buffer);
- length -= sizeof(std::size_t);
- ptr += sizeof(std::size_t);
- }
- }
-
- if (length > 0) {
- std::size_t buffer = 0;
- std::memcpy(&buffer, ptr, length);
- hash_float_combine(seed, buffer);
- }
-
- return seed;
- }
-
- template <typename Float, unsigned digits, unsigned max_exponent>
- struct enable_binary_hash
- {
- BOOST_STATIC_CONSTANT(bool, value =
- std::numeric_limits<Float>::is_iec559 &&
- std::numeric_limits<Float>::digits == digits &&
- std::numeric_limits<Float>::radix == 2 &&
- std::numeric_limits<Float>::max_exponent == max_exponent);
- };
-
- template <typename Float>
- inline std::size_t float_hash_impl(Float v,
- BOOST_DEDUCED_TYPENAME boost::enable_if_c<
- enable_binary_hash<Float, 24, 128>::value,
- std::size_t>::type)
- {
- return hash_binary((char*) &v, 4);
- }
-
-
- template <typename Float>
- inline std::size_t float_hash_impl(Float v,
- BOOST_DEDUCED_TYPENAME boost::enable_if_c<
- enable_binary_hash<Float, 53, 1024>::value,
- std::size_t>::type)
- {
- return hash_binary((char*) &v, 8);
- }
-
- template <typename Float>
- inline std::size_t float_hash_impl(Float v,
- BOOST_DEDUCED_TYPENAME boost::enable_if_c<
- enable_binary_hash<Float, 64, 16384>::value,
- std::size_t>::type)
- {
- return hash_binary((char*) &v, 10);
- }
-
- template <typename Float>
- inline std::size_t float_hash_impl(Float v,
- BOOST_DEDUCED_TYPENAME boost::enable_if_c<
- enable_binary_hash<Float, 113, 16384>::value,
- std::size_t>::type)
- {
- return hash_binary((char*) &v, 16);
- }
-
- ////////////////////////////////////////////////////////////////////////
- // Portable hash function
- //
- // Used as a fallback when the binary hash function isn't supported.
-
- template <class T>
- inline std::size_t float_hash_impl2(T v)
- {
- boost::hash_detail::call_frexp<T> frexp;
- boost::hash_detail::call_ldexp<T> ldexp;
-
- int exp = 0;
-
- v = frexp(v, &exp);
-
- // A postive value is easier to hash, so combine the
- // sign with the exponent and use the absolute value.
- if(v < 0) {
- v = -v;
- exp += limits<T>::max_exponent -
- limits<T>::min_exponent;
- }
-
- v = ldexp(v, limits<std::size_t>::digits);
- std::size_t seed = static_cast<std::size_t>(v);
- v -= static_cast<T>(seed);
-
- // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
- std::size_t const length
- = (limits<T>::digits *
- boost::static_log2<limits<T>::radix>::value
- + limits<std::size_t>::digits - 1)
- / limits<std::size_t>::digits;
-
- for(std::size_t i = 0; i != length; ++i)
- {
- v = ldexp(v, limits<std::size_t>::digits);
- std::size_t part = static_cast<std::size_t>(v);
- v -= static_cast<T>(part);
- hash_float_combine(seed, part);
- }
-
- hash_float_combine(seed, static_cast<std::size_t>(exp));
-
- return seed;
- }
-
-#if !defined(BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC)
- template <class T>
- inline std::size_t float_hash_impl(T v, ...)
- {
- typedef BOOST_DEDUCED_TYPENAME select_hash_type<T>::type type;
- return float_hash_impl2(static_cast<type>(v));
- }
-#endif
- }
-}
-
-#if BOOST_HASH_USE_FPCLASSIFY
-
-#include <boost/config/no_tr1/cmath.hpp>
-
-namespace boost
-{
- namespace hash_detail
- {
- template <class T>
- inline std::size_t float_hash_value(T v)
- {
-#if defined(fpclassify)
- switch (fpclassify(v))
-#elif BOOST_HASH_CONFORMANT_FLOATS
- switch (std::fpclassify(v))
-#else
- using namespace std;
- switch (fpclassify(v))
-#endif
- {
- case FP_ZERO:
- return 0;
- case FP_INFINITE:
- return (std::size_t)(v > 0 ? -1 : -2);
- case FP_NAN:
- return (std::size_t)(-3);
- case FP_NORMAL:
- case FP_SUBNORMAL:
- return float_hash_impl(v, 0);
- default:
- BOOST_ASSERT(0);
- return 0;
- }
- }
- }
-}
-
-#else // !BOOST_HASH_USE_FPCLASSIFY
-
-namespace boost
-{
- namespace hash_detail
- {
- template <class T>
- inline bool is_zero(T v)
- {
-#if !defined(__GNUC__) && !defined(__clang__)
- return v == 0;
-#else
- // GCC's '-Wfloat-equal' will complain about comparing
- // v to 0, but because it disables warnings for system
- // headers it won't complain if you use std::equal_to to
- // compare with 0. Resulting in this silliness:
- return std::equal_to<T>()(v, 0);
-#endif
- }
-
- template <class T>
- inline std::size_t float_hash_value(T v)
- {
- return boost::hash_detail::is_zero(v) ? 0 : float_hash_impl(v, 0);
- }
- }
-}
-
-#endif // BOOST_HASH_USE_FPCLASSIFY
-
-#undef BOOST_HASH_USE_FPCLASSIFY
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-#endif
--- /dev/null
+// Copyright 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP
+#define BOOST_HASH_DETAIL_HASH_MIX_HPP
+
+#include <boost/cstdint.hpp>
+#include <cstddef>
+#include <climits>
+
+namespace boost
+{
+namespace hash_detail
+{
+
+template<std::size_t Bits> struct hash_mix_impl;
+
+// hash_mix for 64 bit size_t
+//
+// The general "xmxmx" form of state of the art 64 bit mixers originates
+// from Murmur3 by Austin Appleby, which uses the following function as
+// its "final mix":
+//
+// k ^= k >> 33;
+// k *= 0xff51afd7ed558ccd;
+// k ^= k >> 33;
+// k *= 0xc4ceb9fe1a85ec53;
+// k ^= k >> 33;
+//
+// (https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp)
+//
+// It has subsequently been improved multiple times by different authors
+// by changing the constants. The most well known improvement is the
+// so-called "variant 13" function by David Stafford:
+//
+// k ^= k >> 30;
+// k *= 0xbf58476d1ce4e5b9;
+// k ^= k >> 27;
+// k *= 0x94d049bb133111eb;
+// k ^= k >> 31;
+//
+// (https://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html)
+//
+// This mixing function is used in the splitmix64 RNG:
+// http://xorshift.di.unimi.it/splitmix64.c
+//
+// We use Jon Maiga's implementation from
+// http://jonkagstrom.com/mx3/mx3_rev2.html
+//
+// x ^= x >> 32;
+// x *= 0xe9846af9b1a615d;
+// x ^= x >> 32;
+// x *= 0xe9846af9b1a615d;
+// x ^= x >> 28;
+//
+// An equally good alternative is Pelle Evensen's Moremur:
+//
+// x ^= x >> 27;
+// x *= 0x3C79AC492BA7B653;
+// x ^= x >> 33;
+// x *= 0x1C69B3F74AC4AE35;
+// x ^= x >> 27;
+//
+// (https://mostlymangling.blogspot.com/2019/12/stronger-better-morer-moremur-better.html)
+
+template<> struct hash_mix_impl<64>
+{
+ inline static boost::uint64_t fn( boost::uint64_t x )
+ {
+ boost::uint64_t const m = (boost::uint64_t(0xe9846af) << 32) + 0x9b1a615d;
+
+ x ^= x >> 32;
+ x *= m;
+ x ^= x >> 32;
+ x *= m;
+ x ^= x >> 28;
+
+ return x;
+ }
+};
+
+// hash_mix for 32 bit size_t
+//
+// We use the "best xmxmx" implementation from
+// https://github.com/skeeto/hash-prospector/issues/19
+
+template<> struct hash_mix_impl<32>
+{
+ inline static boost::uint32_t fn( boost::uint32_t x )
+ {
+ boost::uint32_t const m1 = 0x21f0aaad;
+ boost::uint32_t const m2 = 0x735a2d97;
+
+ x ^= x >> 16;
+ x *= m1;
+ x ^= x >> 15;
+ x *= m2;
+ x ^= x >> 15;
+
+ return x;
+ }
+};
+
+inline std::size_t hash_mix( std::size_t v )
+{
+ return hash_mix_impl<sizeof(std::size_t) * CHAR_BIT>::fn( v );
+}
+
+} // namespace hash_detail
+} // namespace boost
+
+#endif // #ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP
--- /dev/null
+// Copyright 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_DETAIL_HASH_RANGE_HPP
+#define BOOST_HASH_DETAIL_HASH_RANGE_HPP
+
+#include <boost/container_hash/hash_fwd.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/cstdint.hpp>
+#include <cstddef>
+#include <climits>
+#include <iterator>
+
+namespace boost
+{
+namespace hash_detail
+{
+
+template<class T> struct is_char_type: public boost::false_type {};
+
+#if CHAR_BIT == 8
+
+template<> struct is_char_type<char>: public boost::true_type {};
+template<> struct is_char_type<signed char>: public boost::true_type {};
+template<> struct is_char_type<unsigned char>: public boost::true_type {};
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+template<> struct is_char_type<char8_t>: public boost::true_type {};
+#endif
+
+#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
+template<> struct is_char_type<std::byte>: public boost::true_type {};
+#endif
+
+#endif
+
+template<class It>
+inline typename boost::enable_if_<
+ !is_char_type<typename std::iterator_traits<It>::value_type>::value,
+std::size_t >::type
+ hash_range( std::size_t seed, It first, It last )
+{
+ for( ; first != last; ++first )
+ {
+ hash_combine<typename std::iterator_traits<It>::value_type>( seed, *first );
+ }
+
+ return seed;
+}
+
+template<class It>
+inline typename boost::enable_if_<
+ is_char_type<typename std::iterator_traits<It>::value_type>::value &&
+ is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value,
+std::size_t>::type
+ hash_range( std::size_t seed, It first, It last )
+{
+ std::size_t n = static_cast<std::size_t>( last - first );
+
+ for( ; n >= 4; first += 4, n -= 4 )
+ {
+ // clang 5+, gcc 5+ figure out this pattern and use a single mov on x86
+ // gcc on s390x and power BE even knows how to use load-reverse
+
+ boost::uint32_t w =
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[0] ) ) |
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[1] ) ) << 8 |
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[2] ) ) << 16 |
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[3] ) ) << 24;
+
+ hash_combine( seed, w );
+ }
+
+ {
+ // add a trailing suffix byte of 0x01 because otherwise sequences of
+ // trailing zeroes are indistinguishable from end of string
+
+ boost::uint32_t w = 0x01u;
+
+ switch( n )
+ {
+ case 1:
+
+ w =
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[0] ) ) |
+ 0x0100u;
+
+ break;
+
+ case 2:
+
+ w =
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[0] ) ) |
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[1] ) ) << 8 |
+ 0x010000u;
+
+ break;
+
+ case 3:
+
+ w =
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[0] ) ) |
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[1] ) ) << 8 |
+ static_cast<boost::uint32_t>( static_cast<unsigned char>( first[2] ) ) << 16 |
+ 0x01000000u;
+
+ break;
+ }
+
+ hash_combine( seed, w );
+ }
+
+ return seed;
+}
+
+template<class It>
+inline typename boost::enable_if_<
+ is_char_type<typename std::iterator_traits<It>::value_type>::value &&
+ !is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value,
+std::size_t>::type
+ hash_range( std::size_t seed, It first, It last )
+{
+ for( ;; )
+ {
+ boost::uint32_t w = 0;
+
+ if( first == last )
+ {
+ hash_combine( seed, w | 0x01u );
+ return seed;
+ }
+
+ w |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) );
+ ++first;
+
+ if( first == last )
+ {
+ hash_combine( seed, w | 0x0100u );
+ return seed;
+ }
+
+ w |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 8;
+ ++first;
+
+ if( first == last )
+ {
+ hash_combine( seed, w | 0x010000u );
+ return seed;
+ }
+
+ w |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 16;
+ ++first;
+
+ if( first == last )
+ {
+ hash_combine( seed, w | 0x01000000u );
+ return seed;
+ }
+
+ w |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 24;
+ ++first;
+
+ hash_combine( seed, w );
+ }
+}
+
+} // namespace hash_detail
+} // namespace boost
+
+#endif // #ifndef BOOST_HASH_DETAIL_HASH_RANGE_HPP
--- /dev/null
+// Copyright 2005-2009 Daniel James.
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP
+#define BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP
+
+#include <boost/container_hash/hash_fwd.hpp>
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+// no support
+
+#else
+
+#include <tuple>
+
+namespace boost
+{
+namespace hash_detail
+{
+
+template <std::size_t I, typename T>
+inline typename boost::enable_if_<(I == std::tuple_size<T>::value),
+ void>::type
+ hash_combine_tuple(std::size_t&, T const&)
+{
+}
+
+template <std::size_t I, typename T>
+inline typename boost::enable_if_<(I < std::tuple_size<T>::value),
+ void>::type
+ hash_combine_tuple(std::size_t& seed, T const& v)
+{
+ boost::hash_combine(seed, std::get<I>(v));
+ boost::hash_detail::hash_combine_tuple<I + 1>(seed, v);
+}
+
+template <typename T>
+inline std::size_t hash_tuple(T const& v)
+{
+ std::size_t seed = 0;
+ boost::hash_detail::hash_combine_tuple<0>(seed, v);
+ return seed;
+}
+
+} // namespace hash_detail
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template <typename... T>
+inline std::size_t hash_value(std::tuple<T...> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+#else
+
+inline std::size_t hash_value(std::tuple<> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0>
+inline std::size_t hash_value(std::tuple<A0> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1>
+inline std::size_t hash_value(std::tuple<A0, A1> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1, typename A2>
+inline std::size_t hash_value(std::tuple<A0, A1, A2> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1, typename A2, typename A3>
+inline std::size_t hash_value(std::tuple<A0, A1, A2, A3> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1, typename A2, typename A3, typename A4>
+inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
+inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> const& v)
+{
+ return boost::hash_detail::hash_tuple(v);
+}
+
+#endif // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+} // namespace boost
+
+#endif // #if defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+#endif // #ifndef BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP
+++ /dev/null
-
-// Copyright 2005-2009 Daniel James.
-// 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)
-//
-// On some platforms std::limits gives incorrect values for long double.
-// This tries to work around them.
-
-#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER)
-#define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#include <boost/limits.hpp>
-
-// On OpenBSD, numeric_limits is not reliable for long doubles, but
-// the macros defined in <float.h> are and support long double when STLport
-// doesn't.
-
-#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE)
-#include <float.h>
-#endif
-
-namespace boost
-{
- namespace hash_detail
- {
- template <class T>
- struct limits : std::numeric_limits<T> {};
-
-#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE)
- template <>
- struct limits<long double>
- : std::numeric_limits<long double>
- {
- static long double epsilon() {
- return LDBL_EPSILON;
- }
-
- static long double (max)() {
- return LDBL_MAX;
- }
-
- static long double (min)() {
- return LDBL_MIN;
- }
-
- BOOST_STATIC_CONSTANT(int, digits = LDBL_MANT_DIG);
- BOOST_STATIC_CONSTANT(int, max_exponent = LDBL_MAX_EXP);
- BOOST_STATIC_CONSTANT(int, min_exponent = LDBL_MIN_EXP);
-#if defined(_STLP_NO_LONG_DOUBLE)
- BOOST_STATIC_CONSTANT(int, radix = FLT_RADIX);
-#endif
- };
-#endif // __OpenBSD__
- }
-}
-
-#endif
+++ /dev/null
-
-// Copyright 2005-2009 Daniel James.
-// 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)
-
-// Based on Peter Dimov's proposal
-// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
-// issue 6.18.
-
-// This implements the extensions to the standard.
-// It's undocumented, so you shouldn't use it....
-
-#if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
-#define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#include <boost/container_hash/hash.hpp>
-#include <boost/detail/container_fwd.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/static_assert.hpp>
-#include <vector>
-
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
-# include <array>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
-# include <tuple>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_MEMORY)
-# include <memory>
-#endif
-
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#include <boost/type_traits/is_array.hpp>
-#endif
-
-namespace boost
-{
- template <class A, class B>
- std::size_t hash_value(std::pair<A, B> const&);
- template <class T, class A>
- std::size_t hash_value(std::vector<T, A> const&);
- template <class T, class A>
- std::size_t hash_value(std::list<T, A> const& v);
- template <class T, class A>
- std::size_t hash_value(std::deque<T, A> const& v);
- template <class K, class C, class A>
- std::size_t hash_value(std::set<K, C, A> const& v);
- template <class K, class C, class A>
- std::size_t hash_value(std::multiset<K, C, A> const& v);
- template <class K, class T, class C, class A>
- std::size_t hash_value(std::map<K, T, C, A> const& v);
- template <class K, class T, class C, class A>
- std::size_t hash_value(std::multimap<K, T, C, A> const& v);
-
- template <class T>
- std::size_t hash_value(std::complex<T> const&);
-
- template <class A, class B>
- std::size_t hash_value(std::pair<A, B> const& v)
- {
- std::size_t seed = 0;
- boost::hash_combine(seed, v.first);
- boost::hash_combine(seed, v.second);
- return seed;
- }
-
- inline std::size_t hash_range(
- std::vector<bool>::iterator first,
- std::vector<bool>::iterator last)
- {
- std::size_t seed = 0;
-
- for(; first != last; ++first)
- {
- hash_combine<bool>(seed, *first);
- }
-
- return seed;
- }
-
- inline std::size_t hash_range(
- std::vector<bool>::const_iterator first,
- std::vector<bool>::const_iterator last)
- {
- std::size_t seed = 0;
-
- for(; first != last; ++first)
- {
- hash_combine<bool>(seed, *first);
- }
-
- return seed;
- }
-
- inline void hash_range(
- std::size_t& seed,
- std::vector<bool>::iterator first,
- std::vector<bool>::iterator last)
- {
- for(; first != last; ++first)
- {
- hash_combine<bool>(seed, *first);
- }
- }
-
- inline void hash_range(
- std::size_t& seed,
- std::vector<bool>::const_iterator first,
- std::vector<bool>::const_iterator last)
- {
- for(; first != last; ++first)
- {
- hash_combine<bool>(seed, *first);
- }
- }
-
- template <class T, class A>
- std::size_t hash_value(std::vector<T, A> const& v)
- {
- return boost::hash_range(v.begin(), v.end());
- }
-
- template <class T, class A>
- std::size_t hash_value(std::list<T, A> const& v)
- {
- return boost::hash_range(v.begin(), v.end());
- }
-
- template <class T, class A>
- std::size_t hash_value(std::deque<T, A> const& v)
- {
- return boost::hash_range(v.begin(), v.end());
- }
-
- template <class K, class C, class A>
- std::size_t hash_value(std::set<K, C, A> const& v)
- {
- return boost::hash_range(v.begin(), v.end());
- }
-
- template <class K, class C, class A>
- std::size_t hash_value(std::multiset<K, C, A> const& v)
- {
- return boost::hash_range(v.begin(), v.end());
- }
-
- template <class K, class T, class C, class A>
- std::size_t hash_value(std::map<K, T, C, A> const& v)
- {
- return boost::hash_range(v.begin(), v.end());
- }
-
- template <class K, class T, class C, class A>
- std::size_t hash_value(std::multimap<K, T, C, A> const& v)
- {
- return boost::hash_range(v.begin(), v.end());
- }
-
- template <class T>
- std::size_t hash_value(std::complex<T> const& v)
- {
- boost::hash<T> hasher;
- std::size_t seed = hasher(v.imag());
- seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
- return seed;
- }
-
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
- template <class T, std::size_t N>
- std::size_t hash_value(std::array<T, N> const& v)
- {
- return boost::hash_range(v.begin(), v.end());
- }
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
- namespace hash_detail {
- template <std::size_t I, typename T>
- inline typename boost::enable_if_c<(I == std::tuple_size<T>::value),
- void>::type
- hash_combine_tuple(std::size_t&, T const&)
- {
- }
-
- template <std::size_t I, typename T>
- inline typename boost::enable_if_c<(I < std::tuple_size<T>::value),
- void>::type
- hash_combine_tuple(std::size_t& seed, T const& v)
- {
- boost::hash_combine(seed, std::get<I>(v));
- boost::hash_detail::hash_combine_tuple<I + 1>(seed, v);
- }
-
- template <typename T>
- inline std::size_t hash_tuple(T const& v)
- {
- std::size_t seed = 0;
- boost::hash_detail::hash_combine_tuple<0>(seed, v);
- return seed;
- }
- }
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
- template <typename... T>
- inline std::size_t hash_value(std::tuple<T...> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-#else
-
- inline std::size_t hash_value(std::tuple<> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0>
- inline std::size_t hash_value(std::tuple<A0> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1>
- inline std::size_t hash_value(std::tuple<A0, A1> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1, typename A2>
- inline std::size_t hash_value(std::tuple<A0, A1, A2> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1, typename A2, typename A3>
- inline std::size_t hash_value(std::tuple<A0, A1, A2, A3> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1, typename A2, typename A3, typename A4>
- inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
- inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
- inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
- inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
- inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
- template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
- inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> const& v)
- {
- return boost::hash_detail::hash_tuple(v);
- }
-
-#endif
-
-#endif
-
-#if !defined(BOOST_NO_CXX11_SMART_PTR)
- template <typename T>
- inline std::size_t hash_value(std::shared_ptr<T> const& x) {
- return boost::hash_value(x.get());
- }
-
- template <typename T, typename Deleter>
- inline std::size_t hash_value(std::unique_ptr<T, Deleter> const& x) {
- return boost::hash_value(x.get());
- }
-#endif
-
- //
- // call_hash_impl
- //
-
- // On compilers without function template ordering, this deals with arrays.
-
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
- namespace hash_detail
- {
- template <bool IsArray>
- struct call_hash_impl
- {
- template <class T>
- struct inner
- {
- static std::size_t call(T const& v)
- {
- using namespace boost;
- return hash_value(v);
- }
- };
- };
-
- template <>
- struct call_hash_impl<true>
- {
- template <class Array>
- struct inner
- {
- static std::size_t call(Array const& v)
- {
- const int size = sizeof(v) / sizeof(*v);
- return boost::hash_range(v, v + size);
- }
- };
- };
-
- template <class T>
- struct call_hash
- : public call_hash_impl<boost::is_array<T>::value>
- ::BOOST_NESTED_TEMPLATE inner<T>
- {
- };
- }
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
- //
- // boost::hash
- //
-
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
- template <class T> struct hash
- : boost::hash_detail::hash_base<T>
- {
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
- std::size_t operator()(T const& val) const
- {
- return hash_value(val);
- }
-#else
- std::size_t operator()(T const& val) const
- {
- return hash_detail::call_hash<T>::call(val);
- }
-#endif
- };
-
-#if BOOST_WORKAROUND(__DMC__, <= 0x848)
- template <class T, unsigned int n> struct hash<T[n]>
- : boost::hash_detail::hash_base<T[n]>
- {
- std::size_t operator()(const T* val) const
- {
- return boost::hash_range(val, val+n);
- }
- };
-#endif
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
- // On compilers without partial specialization, boost::hash<T>
- // has already been declared to deal with pointers, so just
- // need to supply the non-pointer version of hash_impl.
-
- namespace hash_detail
- {
- template <bool IsPointer>
- struct hash_impl;
-
- template <>
- struct hash_impl<false>
- {
- template <class T>
- struct inner
- : boost::hash_detail::hash_base<T>
- {
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
- std::size_t operator()(T const& val) const
- {
- return hash_value(val);
- }
-#else
- std::size_t operator()(T const& val) const
- {
- return hash_detail::call_hash<T>::call(val);
- }
-#endif
- };
- };
- }
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-}
-
-#endif
-
// Copyright 2005-2014 Daniel James.
-// 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)
-
-// Based on Peter Dimov's proposal
-// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
-// issue 6.18.
-//
-// This also contains public domain code from MurmurHash. From the
-// MurmurHash header:
+// Copyright 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
-// MurmurHash3 was written by Austin Appleby, and is placed in the public
-// domain. The author hereby disclaims copyright to this source code.
+// Based on Peter Dimov's proposal
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+// issue 6.18.
-#if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP)
+#ifndef BOOST_FUNCTIONAL_HASH_HASH_HPP
#define BOOST_FUNCTIONAL_HASH_HASH_HPP
#include <boost/container_hash/hash_fwd.hpp>
-#include <functional>
-#include <boost/container_hash/detail/hash_float.hpp>
-#include <string>
-#include <boost/limits.hpp>
+#include <boost/container_hash/is_range.hpp>
+#include <boost/container_hash/is_contiguous_range.hpp>
+#include <boost/container_hash/is_unordered_range.hpp>
+#include <boost/container_hash/is_described_class.hpp>
+#include <boost/container_hash/detail/hash_tuple.hpp>
+#include <boost/container_hash/detail/hash_mix.hpp>
+#include <boost/container_hash/detail/hash_range.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_integral.hpp>
-#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/type_traits/conjunction.hpp>
+#include <boost/type_traits/is_union.hpp>
+#include <boost/describe/bases.hpp>
+#include <boost/describe/members.hpp>
#include <boost/cstdint.hpp>
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-#include <boost/type_traits/is_pointer.hpp>
+#if defined(BOOST_DESCRIBE_CXX14)
+# include <boost/mp11/algorithm.hpp>
+#endif
+
+#include <string>
+#include <iterator>
+#include <complex>
+#include <utility>
+#include <limits>
+#include <climits>
+#include <cstring>
+
+#if !defined(BOOST_NO_CXX11_SMART_PTR)
+# include <memory>
#endif
#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
#include <system_error>
#endif
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-
-#if BOOST_MSVC >= 1400
-#pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values
- // are always of range '0' to '4294967295'.
- // Loop executes infinitely.
-#endif
-
-#endif
-
-#if BOOST_WORKAROUND(__GNUC__, < 3) \
- && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-#define BOOST_HASH_CHAR_TRAITS string_char_traits
-#else
-#define BOOST_HASH_CHAR_TRAITS char_traits
-#endif
-
-#if defined(_MSC_VER)
-# define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) _rotl(x,r)
-#else
-# define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
-#endif
-
-// Detect whether standard library has C++17 headers
-
-#if !defined(BOOST_HASH_CXX17)
-# if defined(BOOST_MSVC)
-# if defined(_HAS_CXX17) && _HAS_CXX17
-# define BOOST_HASH_CXX17 1
-# endif
-# elif defined(__cplusplus) && __cplusplus >= 201703
-# define BOOST_HASH_CXX17 1
-# endif
+#if !defined(BOOST_NO_CXX17_HDR_OPTIONAL)
+#include <optional>
#endif
-#if !defined(BOOST_HASH_CXX17)
-# define BOOST_HASH_CXX17 0
+#if !defined(BOOST_NO_CXX17_HDR_VARIANT)
+#include <variant>
#endif
-#if BOOST_HASH_CXX17 && defined(__has_include)
-# if !defined(BOOST_HASH_HAS_STRING_VIEW) && __has_include(<string_view>)
-# define BOOST_HASH_HAS_STRING_VIEW 1
-# endif
-# if !defined(BOOST_HASH_HAS_OPTIONAL) && __has_include(<optional>)
-# define BOOST_HASH_HAS_OPTIONAL 1
-# endif
-# if !defined(BOOST_HASH_HAS_VARIANT) && __has_include(<variant>)
-# define BOOST_HASH_HAS_VARIANT 1
-# endif
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
#endif
-#if !defined(BOOST_HASH_HAS_STRING_VIEW)
-# define BOOST_HASH_HAS_STRING_VIEW 0
-#endif
-
-#if !defined(BOOST_HASH_HAS_OPTIONAL)
-# define BOOST_HASH_HAS_OPTIONAL 0
-#endif
-
-#if !defined(BOOST_HASH_HAS_VARIANT)
-# define BOOST_HASH_HAS_VARIANT 0
-#endif
-
-#if BOOST_HASH_HAS_STRING_VIEW
-# include <string_view>
-#endif
+namespace boost
+{
-#if BOOST_HASH_HAS_OPTIONAL
-# include <optional>
-#endif
+ //
+ // boost::hash_value
+ //
-#if BOOST_HASH_HAS_VARIANT
-# include <variant>
-#endif
+ // integral types
-namespace boost
-{
namespace hash_detail
{
-#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC
- template <typename T>
- struct hash_base
+ template<class T,
+ bool bigger_than_size_t = (sizeof(T) > sizeof(std::size_t)),
+ bool is_unsigned = boost::is_unsigned<T>::value,
+ std::size_t size_t_bits = sizeof(std::size_t) * CHAR_BIT,
+ std::size_t type_bits = sizeof(T) * CHAR_BIT>
+ struct hash_integral_impl;
+
+ template<class T, bool is_unsigned, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, false, is_unsigned, size_t_bits, type_bits>
{
- typedef T argument_type;
- typedef std::size_t result_type;
+ static std::size_t fn( T v )
+ {
+ return static_cast<std::size_t>( v );
+ }
};
-#else
- template <typename T>
- struct hash_base : std::unary_function<T, std::size_t> {};
-#endif
- struct enable_hash_value { typedef std::size_t type; };
-
- template <typename T> struct basic_numbers {};
- template <typename T> struct long_numbers;
- template <typename T> struct ulong_numbers;
- template <typename T> struct float_numbers {};
-
- template <> struct basic_numbers<bool> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<char> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<unsigned char> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<signed char> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<short> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<unsigned short> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<int> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<unsigned int> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<long> :
- boost::hash_detail::enable_hash_value {};
- template <> struct basic_numbers<unsigned long> :
- boost::hash_detail::enable_hash_value {};
-
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- template <> struct basic_numbers<wchar_t> :
- boost::hash_detail::enable_hash_value {};
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
- template <> struct basic_numbers<char16_t> :
- boost::hash_detail::enable_hash_value {};
-#endif
+ template<class T, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, true, false, size_t_bits, type_bits>
+ {
+ static std::size_t fn( T v )
+ {
+ typedef typename boost::make_unsigned<T>::type U;
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
- template <> struct basic_numbers<char32_t> :
- boost::hash_detail::enable_hash_value {};
-#endif
+ if( v >= 0 )
+ {
+ return hash_integral_impl<U>::fn( static_cast<U>( v ) );
+ }
+ else
+ {
+ return ~hash_integral_impl<U>::fn( static_cast<U>( ~static_cast<U>( v ) ) );
+ }
+ }
+ };
- // long_numbers is defined like this to allow for separate
- // specialization for long_long and int128_type, in case
- // they conflict.
- template <typename T> struct long_numbers2 {};
- template <typename T> struct ulong_numbers2 {};
- template <typename T> struct long_numbers : long_numbers2<T> {};
- template <typename T> struct ulong_numbers : ulong_numbers2<T> {};
-
-#if !defined(BOOST_NO_LONG_LONG)
- template <> struct long_numbers<boost::long_long_type> :
- boost::hash_detail::enable_hash_value {};
- template <> struct ulong_numbers<boost::ulong_long_type> :
- boost::hash_detail::enable_hash_value {};
-#endif
+ template<class T> struct hash_integral_impl<T, true, true, 32, 64>
+ {
+ static std::size_t fn( T v )
+ {
+ std::size_t seed = 0;
-#if defined(BOOST_HAS_INT128)
- template <> struct long_numbers2<boost::int128_type> :
- boost::hash_detail::enable_hash_value {};
- template <> struct ulong_numbers2<boost::uint128_type> :
- boost::hash_detail::enable_hash_value {};
-#endif
+ seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
+ seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
- template <> struct float_numbers<float> :
- boost::hash_detail::enable_hash_value {};
- template <> struct float_numbers<double> :
- boost::hash_detail::enable_hash_value {};
- template <> struct float_numbers<long double> :
- boost::hash_detail::enable_hash_value {};
- }
+ return seed;
+ }
+ };
- template <typename T>
- typename boost::hash_detail::basic_numbers<T>::type hash_value(T);
- template <typename T>
- typename boost::hash_detail::long_numbers<T>::type hash_value(T);
- template <typename T>
- typename boost::hash_detail::ulong_numbers<T>::type hash_value(T);
+ template<class T> struct hash_integral_impl<T, true, true, 32, 128>
+ {
+ static std::size_t fn( T v )
+ {
+ std::size_t seed = 0;
- template <typename T>
- typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
- hash_value(T);
+ seed = static_cast<std::size_t>( v >> 96 ) + hash_detail::hash_mix( seed );
+ seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
+ seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
+ seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
-#if !BOOST_WORKAROUND(__DMC__, <= 0x848)
- template <class T> std::size_t hash_value(T* const&);
-#else
- template <class T> std::size_t hash_value(T*);
-#endif
+ return seed;
+ }
+ };
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
- template< class T, unsigned N >
- std::size_t hash_value(const T (&x)[N]);
+ template<class T> struct hash_integral_impl<T, true, true, 64, 128>
+ {
+ static std::size_t fn( T v )
+ {
+ std::size_t seed = 0;
- template< class T, unsigned N >
- std::size_t hash_value(T (&x)[N]);
-#endif
+ seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
+ seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
- template <class Ch, class A>
- std::size_t hash_value(
- std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
+ return seed;
+ }
+ };
-#if BOOST_HASH_HAS_STRING_VIEW
- template <class Ch>
- std::size_t hash_value(
- std::basic_string_view<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch> > const&);
-#endif
+ } // namespace hash_detail
template <typename T>
- typename boost::hash_detail::float_numbers<T>::type hash_value(T);
+ typename boost::enable_if_<boost::is_integral<T>::value, std::size_t>::type
+ hash_value( T v )
+ {
+ return hash_detail::hash_integral_impl<T>::fn( v );
+ }
+
+ // enumeration types
-#if BOOST_HASH_HAS_OPTIONAL
template <typename T>
- std::size_t hash_value(std::optional<T> const&);
-#endif
+ typename boost::enable_if_<boost::is_enum<T>::value, std::size_t>::type
+ hash_value( T v )
+ {
+ // This should in principle return the equivalent of
+ //
+ // boost::hash_value( to_underlying(v) );
+ //
+ // However, the C++03 implementation of underlying_type,
+ //
+ // conditional<is_signed<T>, make_signed<T>, make_unsigned<T>>::type::type
+ //
+ // generates a legitimate -Wconversion warning in is_signed,
+ // because -1 is not a valid enum value when all the enumerators
+ // are nonnegative.
+ //
+ // So the legacy implementation will have to do for now.
+
+ return static_cast<std::size_t>( v );
+ }
-#if BOOST_HASH_HAS_VARIANT
- std::size_t hash_value(std::monostate);
- template <typename... Types>
- std::size_t hash_value(std::variant<Types...> const&);
-#endif
+ // floating point types
-#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
- std::size_t hash_value(std::type_index);
-#endif
+ namespace hash_detail
+ {
+ template<class T,
+ std::size_t Bits = sizeof(T) * CHAR_BIT,
+ int Digits = std::numeric_limits<T>::digits>
+ struct hash_float_impl;
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
- std::size_t hash_value(std::error_code const&);
- std::size_t hash_value(std::error_condition const&);
-#endif
+ // float
+ template<class T, int Digits> struct hash_float_impl<T, 32, Digits>
+ {
+ static std::size_t fn( T v )
+ {
+ boost::uint32_t w;
+ std::memcpy( &w, &v, sizeof( v ) );
- // Implementation
+ return w;
+ }
+ };
- namespace hash_detail
- {
- template <class T>
- inline std::size_t hash_value_signed(T val)
+ // double
+ template<class T, int Digits> struct hash_float_impl<T, 64, Digits>
{
- const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
- // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
- const int length = (std::numeric_limits<T>::digits - 1)
- / static_cast<int>(size_t_bits);
-
- std::size_t seed = 0;
- T positive = val < 0 ? -1 - val : val;
-
- // Hopefully, this loop can be unrolled.
- for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
- {
- seed ^= (std::size_t) (positive >> i) + (seed<<6) + (seed>>2);
- }
- seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
-
- return seed;
- }
+ static std::size_t fn( T v )
+ {
+ boost::uint64_t w;
+ std::memcpy( &w, &v, sizeof( v ) );
+
+ return hash_value( w );
+ }
+ };
- template <class T>
- inline std::size_t hash_value_unsigned(T val)
+ // 80 bit long double in 12 bytes
+ template<class T> struct hash_float_impl<T, 96, 64>
{
- const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
- // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
- const int length = (std::numeric_limits<T>::digits - 1)
- / static_cast<int>(size_t_bits);
+ static std::size_t fn( T v )
+ {
+ boost::uint64_t w[ 2 ] = {};
+ std::memcpy( &w, &v, 80 / CHAR_BIT );
- std::size_t seed = 0;
+ std::size_t seed = 0;
- // Hopefully, this loop can be unrolled.
- for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
- {
- seed ^= (std::size_t) (val >> i) + (seed<<6) + (seed>>2);
- }
- seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
+ seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
+ seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
- return seed;
- }
+ return seed;
+ }
+ };
- template <typename SizeT>
- inline void hash_combine_impl(SizeT& seed, SizeT value)
+ // 80 bit long double in 16 bytes
+ template<class T> struct hash_float_impl<T, 128, 64>
{
- seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
- }
+ static std::size_t fn( T v )
+ {
+ boost::uint64_t w[ 2 ] = {};
+ std::memcpy( &w, &v, 80 / CHAR_BIT );
- inline void hash_combine_impl(boost::uint32_t& h1,
- boost::uint32_t k1)
- {
- const uint32_t c1 = 0xcc9e2d51;
- const uint32_t c2 = 0x1b873593;
+ std::size_t seed = 0;
- k1 *= c1;
- k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
- k1 *= c2;
+ seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
+ seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
- h1 ^= k1;
- h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
- h1 = h1*5+0xe6546b64;
- }
+ return seed;
+ }
+ };
+ // 128 bit long double
+ template<class T, int Digits> struct hash_float_impl<T, 128, Digits>
+ {
+ static std::size_t fn( T v )
+ {
+ boost::uint64_t w[ 2 ];
+ std::memcpy( &w, &v, sizeof( v ) );
-// Don't define 64-bit hash combine on platforms without 64 bit integers,
-// and also not for 32-bit gcc as it warns about the 64-bit constant.
-#if !defined(BOOST_NO_INT64_T) && \
- !(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
+ std::size_t seed = 0;
- inline void hash_combine_impl(boost::uint64_t& h,
- boost::uint64_t k)
- {
- const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
- const int r = 47;
+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__
- k *= m;
- k ^= k >> r;
- k *= m;
+ seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
+ seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
- h ^= k;
- h *= m;
+#else
- // Completely arbitrary number, to prevent 0's
- // from hashing to 0.
- h += 0xe6546b64;
- }
+ seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
+ seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
-#endif // BOOST_NO_INT64_T
- }
+#endif
+ return seed;
+ }
+ };
- template <typename T>
- typename boost::hash_detail::basic_numbers<T>::type hash_value(T v)
- {
- return static_cast<std::size_t>(v);
- }
+ } // namespace hash_detail
template <typename T>
- typename boost::hash_detail::long_numbers<T>::type hash_value(T v)
+ typename boost::enable_if_<boost::is_floating_point<T>::value, std::size_t>::type
+ hash_value( T v )
{
- return hash_detail::hash_value_signed(v);
+ return boost::hash_detail::hash_float_impl<T>::fn( v + 0 );
}
- template <typename T>
- typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v)
+ // pointer types
+
+ // `x + (x >> 3)` adjustment by Alberto Barbati and Dave Harris.
+ template <class T> std::size_t hash_value( T* const& v )
{
- return hash_detail::hash_value_unsigned(v);
+ boost::uintptr_t x = reinterpret_cast<boost::uintptr_t>( v );
+ return boost::hash_value( x + (x >> 3) );
}
- template <typename T>
- typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
- hash_value(T v)
+ // array types
+
+ template<class T, std::size_t N>
+ inline std::size_t hash_value( T const (&x)[ N ] )
{
- return static_cast<std::size_t>(v);
+ return boost::hash_range( x, x + N );
}
- // Implementation by Alberto Barbati and Dave Harris.
-#if !BOOST_WORKAROUND(__DMC__, <= 0x848)
- template <class T> std::size_t hash_value(T* const& v)
-#else
- template <class T> std::size_t hash_value(T* v)
-#endif
+ template<class T, std::size_t N>
+ inline std::size_t hash_value( T (&x)[ N ] )
{
-#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
- // for some reason ptrdiff_t on OpenVMS compiler with
- // 64 bit is not 64 bit !!!
- std::size_t x = static_cast<std::size_t>(
- reinterpret_cast<long long int>(v));
-#else
- std::size_t x = static_cast<std::size_t>(
- reinterpret_cast<std::ptrdiff_t>(v));
-#endif
- return x + (x >> 3);
+ return boost::hash_range( x, x + N );
}
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#if BOOST_MSVC <= 1400
-#pragma warning(disable:4267) // 'argument' : conversion from 'size_t' to
- // 'unsigned int', possible loss of data
- // A misguided attempt to detect 64-bit
- // incompatability.
-#endif
-#endif
+ // complex
template <class T>
- inline void hash_combine(std::size_t& seed, T const& v)
+ std::size_t hash_value( std::complex<T> const& v )
{
- boost::hash<T> hasher;
- return boost::hash_detail::hash_combine_impl(seed, hasher(v));
+ std::size_t re = boost::hash<T>()( v.real() );
+ std::size_t im = boost::hash<T>()( v.imag() );
+
+ return re + hash_detail::hash_mix( im );
}
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
+ // pair
- template <class It>
- inline std::size_t hash_range(It first, It last)
+ template <class A, class B>
+ std::size_t hash_value( std::pair<A, B> const& v )
{
std::size_t seed = 0;
- for(; first != last; ++first)
- {
- hash_combine(seed, *first);
- }
+ boost::hash_combine( seed, v.first );
+ boost::hash_combine( seed, v.second );
return seed;
}
- template <class It>
- inline void hash_range(std::size_t& seed, It first, It last)
- {
- for(; first != last; ++first)
- {
- hash_combine(seed, *first);
- }
- }
+ // ranges (list, set, deque...)
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
- template <class T>
- inline std::size_t hash_range(T* first, T* last)
+ template <typename T>
+ typename boost::enable_if_<container_hash::is_range<T>::value && !container_hash::is_contiguous_range<T>::value && !container_hash::is_unordered_range<T>::value, std::size_t>::type
+ hash_value( T const& v )
{
- std::size_t seed = 0;
+ return boost::hash_range( v.begin(), v.end() );
+ }
- for(; first != last; ++first)
- {
- boost::hash<T> hasher;
- seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
- }
+ // contiguous ranges (string, vector, array)
- return seed;
+ template <typename T>
+ typename boost::enable_if_<container_hash::is_contiguous_range<T>::value, std::size_t>::type
+ hash_value( T const& v )
+ {
+ return boost::hash_range( v.data(), v.data() + v.size() );
}
- template <class T>
- inline void hash_range(std::size_t& seed, T* first, T* last)
+ // unordered ranges (unordered_set, unordered_map)
+
+ template <typename T>
+ typename boost::enable_if_<container_hash::is_unordered_range<T>::value, std::size_t>::type
+ hash_value( T const& v )
{
- for(; first != last; ++first)
- {
- boost::hash<T> hasher;
- seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
- }
+ return boost::hash_unordered_range( v.begin(), v.end() );
}
-#endif
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
- template< class T, unsigned N >
- inline std::size_t hash_value(const T (&x)[N])
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ( \
+ ( defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION < 142 ) || \
+ ( !defined(_MSVC_STL_VERSION) && defined(_CPPLIB_VER) && _CPPLIB_VER >= 520 ) )
+
+ // resolve ambiguity with unconstrained stdext::hash_value in <xhash> :-/
+
+ template<template<class...> class L, class... T>
+ typename boost::enable_if_<container_hash::is_range<L<T...>>::value && !container_hash::is_contiguous_range<L<T...>>::value && !container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
+ hash_value( L<T...> const& v )
{
- return hash_range(x, x + N);
+ return boost::hash_range( v.begin(), v.end() );
}
- template< class T, unsigned N >
- inline std::size_t hash_value(T (&x)[N])
+ // contiguous ranges (string, vector, array)
+
+ template<template<class...> class L, class... T>
+ typename boost::enable_if_<container_hash::is_contiguous_range<L<T...>>::value, std::size_t>::type
+ hash_value( L<T...> const& v )
{
- return hash_range(x, x + N);
+ return boost::hash_range( v.data(), v.data() + v.size() );
}
-#endif
- template <class Ch, class A>
- inline std::size_t hash_value(
- std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
+ template<template<class, std::size_t> class L, class T, std::size_t N>
+ typename boost::enable_if_<container_hash::is_contiguous_range<L<T, N>>::value, std::size_t>::type
+ hash_value( L<T, N> const& v )
{
- return hash_range(v.begin(), v.end());
+ return boost::hash_range( v.data(), v.data() + v.size() );
}
-#if BOOST_HASH_HAS_STRING_VIEW
- template <class Ch>
- inline std::size_t hash_value(
- std::basic_string_view<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch> > const& v)
+ // unordered ranges (unordered_set, unordered_map)
+
+ template<template<class...> class L, class... T>
+ typename boost::enable_if_<container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
+ hash_value( L<T...> const& v )
{
- return hash_range(v.begin(), v.end());
+ return boost::hash_unordered_range( v.begin(), v.end() );
}
+
+#endif
+
+ // described classes
+
+#if defined(BOOST_DESCRIBE_CXX14)
+
+#if defined(_MSC_VER) && _MSC_VER == 1900
+# pragma warning(push)
+# pragma warning(disable: 4100) // unreferenced formal parameter
#endif
template <typename T>
- typename boost::hash_detail::float_numbers<T>::type hash_value(T v)
+ typename boost::enable_if_<container_hash::is_described_class<T>::value, std::size_t>::type
+ hash_value( T const& v )
{
- return boost::hash_detail::float_hash_value(v);
- }
+ static_assert( !boost::is_union<T>::value, "described unions are not supported" );
-#if BOOST_HASH_HAS_OPTIONAL
- template <typename T>
- inline std::size_t hash_value(std::optional<T> const& v) {
- if (!v) {
- // Arbitray value for empty optional.
- return 0x12345678;
- } else {
- boost::hash<T> hf;
- return hf(*v);
- }
+ std::size_t r = 0;
+
+ using Bd = describe::describe_bases<T, describe::mod_any_access>;
+
+ mp11::mp_for_each<Bd>([&](auto D){
+
+ using B = typename decltype(D)::type;
+ boost::hash_combine( r, (B const&)v );
+
+ });
+
+ using Md = describe::describe_members<T, describe::mod_any_access>;
+
+ mp11::mp_for_each<Md>([&](auto D){
+
+ boost::hash_combine( r, v.*D.pointer );
+
+ });
+
+ return r;
}
+
+#if defined(_MSC_VER) && _MSC_VER == 1900
+# pragma warning(pop)
#endif
-#if BOOST_HASH_HAS_VARIANT
- inline std::size_t hash_value(std::monostate) {
- return 0x87654321;
+#endif
+
+ // std::unique_ptr, std::shared_ptr
+
+#if !defined(BOOST_NO_CXX11_SMART_PTR)
+
+ template <typename T>
+ std::size_t hash_value( std::shared_ptr<T> const& x )
+ {
+ return boost::hash_value( x.get() );
}
- template <typename... Types>
- inline std::size_t hash_value(std::variant<Types...> const& v) {
- std::size_t seed = 0;
- hash_combine(seed, v.index());
- std::visit([&seed](auto&& x) { hash_combine(seed, x); }, v);
- return seed;
+ template <typename T, typename Deleter>
+ std::size_t hash_value( std::unique_ptr<T, Deleter> const& x )
+ {
+ return boost::hash_value( x.get() );
}
+
#endif
+ // std::type_index
#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
- inline std::size_t hash_value(std::type_index v)
+
+ inline std::size_t hash_value( std::type_index const& v )
{
return v.hash_code();
}
+
#endif
+ // std::error_code, std::error_condition
+
#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
- inline std::size_t hash_value(std::error_code const& v) {
+
+ inline std::size_t hash_value( std::error_code const& v )
+ {
std::size_t seed = 0;
- hash_combine(seed, v.value());
- hash_combine(seed, &v.category());
+
+ boost::hash_combine( seed, v.value() );
+ boost::hash_combine( seed, &v.category() );
+
return seed;
}
- inline std::size_t hash_value(std::error_condition const& v) {
+ inline std::size_t hash_value( std::error_condition const& v )
+ {
std::size_t seed = 0;
- hash_combine(seed, v.value());
- hash_combine(seed, &v.category());
+
+ boost::hash_combine( seed, v.value() );
+ boost::hash_combine( seed, &v.category() );
+
return seed;
}
+
+#endif
+
+ // std::optional
+
+#if !defined(BOOST_NO_CXX17_HDR_OPTIONAL)
+
+ template <typename T>
+ std::size_t hash_value( std::optional<T> const& v )
+ {
+ if( !v )
+ {
+ // Arbitray value for empty optional.
+ return 0x12345678;
+ }
+ else
+ {
+ return boost::hash<T>()(*v);
+ }
+ }
+
+#endif
+
+ // std::variant
+
+#if !defined(BOOST_NO_CXX17_HDR_VARIANT)
+
+ inline std::size_t hash_value( std::monostate )
+ {
+ return 0x87654321;
+ }
+
+ template <typename... Types>
+ std::size_t hash_value( std::variant<Types...> const& v )
+ {
+ std::size_t seed = 0;
+
+ hash_combine( seed, v.index() );
+ std::visit( [&seed](auto&& x) { hash_combine(seed, x); }, v );
+
+ return seed;
+ }
+
#endif
//
- // boost::hash
+ // boost::hash_combine
//
- // Define the specializations required by the standard. The general purpose
- // boost::hash is defined later in extensions.hpp if
- // BOOST_HASH_NO_EXTENSIONS is not defined.
+ template <class T>
+ inline void hash_combine( std::size_t& seed, T const& v )
+ {
+ seed = boost::hash_detail::hash_mix( seed + 0x9e3779b9 + boost::hash<T>()( v ) );
+ }
- // BOOST_HASH_SPECIALIZE - define a specialization for a type which is
- // passed by copy.
//
- // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
- // passed by const reference.
+ // boost::hash_range
//
- // These are undefined later.
-
-#define BOOST_HASH_SPECIALIZE(type) \
- template <> struct hash<type> \
- : public boost::hash_detail::hash_base<type> \
- { \
- std::size_t operator()(type v) const \
- { \
- return boost::hash_value(v); \
- } \
- };
-#define BOOST_HASH_SPECIALIZE_REF(type) \
- template <> struct hash<type> \
- : public boost::hash_detail::hash_base<type> \
- { \
- std::size_t operator()(type const& v) const \
- { \
- return boost::hash_value(v); \
- } \
- };
+ template <class It>
+ inline void hash_range( std::size_t& seed, It first, It last )
+ {
+ seed = hash_detail::hash_range( seed, first, last );
+ }
-#define BOOST_HASH_SPECIALIZE_TEMPLATE_REF(type) \
- struct hash<type> \
- : public boost::hash_detail::hash_base<type> \
- { \
- std::size_t operator()(type const& v) const \
- { \
- return boost::hash_value(v); \
- } \
- };
+ template <class It>
+ inline std::size_t hash_range( It first, It last )
+ {
+ std::size_t seed = 0;
- BOOST_HASH_SPECIALIZE(bool)
- BOOST_HASH_SPECIALIZE(char)
- BOOST_HASH_SPECIALIZE(signed char)
- BOOST_HASH_SPECIALIZE(unsigned char)
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_HASH_SPECIALIZE(wchar_t)
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
- BOOST_HASH_SPECIALIZE(char16_t)
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
- BOOST_HASH_SPECIALIZE(char32_t)
-#endif
- BOOST_HASH_SPECIALIZE(short)
- BOOST_HASH_SPECIALIZE(unsigned short)
- BOOST_HASH_SPECIALIZE(int)
- BOOST_HASH_SPECIALIZE(unsigned int)
- BOOST_HASH_SPECIALIZE(long)
- BOOST_HASH_SPECIALIZE(unsigned long)
-
- BOOST_HASH_SPECIALIZE(float)
- BOOST_HASH_SPECIALIZE(double)
- BOOST_HASH_SPECIALIZE(long double)
-
- BOOST_HASH_SPECIALIZE_REF(std::string)
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_HASH_SPECIALIZE_REF(std::wstring)
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
- BOOST_HASH_SPECIALIZE_REF(std::basic_string<char16_t>)
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
- BOOST_HASH_SPECIALIZE_REF(std::basic_string<char32_t>)
-#endif
+ hash_range( seed, first, last );
-#if BOOST_HASH_HAS_STRING_VIEW
- BOOST_HASH_SPECIALIZE_REF(std::string_view)
-# if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_HASH_SPECIALIZE_REF(std::wstring_view)
-# endif
-# if !defined(BOOST_NO_CXX11_CHAR16_T)
- BOOST_HASH_SPECIALIZE_REF(std::basic_string_view<char16_t>)
-# endif
-# if !defined(BOOST_NO_CXX11_CHAR32_T)
- BOOST_HASH_SPECIALIZE_REF(std::basic_string_view<char32_t>)
-# endif
-#endif
+ return seed;
+ }
-#if !defined(BOOST_NO_LONG_LONG)
- BOOST_HASH_SPECIALIZE(boost::long_long_type)
- BOOST_HASH_SPECIALIZE(boost::ulong_long_type)
-#endif
+ //
+ // boost::hash_unordered_range
+ //
-#if defined(BOOST_HAS_INT128)
- BOOST_HASH_SPECIALIZE(boost::int128_type)
- BOOST_HASH_SPECIALIZE(boost::uint128_type)
-#endif
+ template <class It>
+ inline void hash_unordered_range( std::size_t& seed, It first, It last )
+ {
+ std::size_t r = 0;
+ std::size_t const s2( seed );
-#if BOOST_HASH_HAS_OPTIONAL
- template <typename T>
- BOOST_HASH_SPECIALIZE_TEMPLATE_REF(std::optional<T>)
-#endif
+ for( ; first != last; ++first )
+ {
+ std::size_t s3( s2 );
-#if !defined(BOOST_HASH_HAS_VARIANT)
- template <typename... T>
- BOOST_HASH_SPECIALIZE_TEMPLATE_REF(std::variant<T...>)
- BOOST_HASH_SPECIALIZE(std::monostate)
-#endif
+ hash_combine<typename std::iterator_traits<It>::value_type>( s3, *first );
-#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
- BOOST_HASH_SPECIALIZE(std::type_index)
-#endif
+ r += s3;
+ }
-#undef BOOST_HASH_SPECIALIZE
-#undef BOOST_HASH_SPECIALIZE_REF
-#undef BOOST_HASH_SPECIALIZE_TEMPLATE_REF
+ seed += r;
+ }
-// Specializing boost::hash for pointers.
+ template <class It>
+ inline std::size_t hash_unordered_range( It first, It last )
+ {
+ std::size_t seed = 0;
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+ hash_unordered_range( seed, first, last );
- template <class T>
- struct hash<T*>
- : public boost::hash_detail::hash_base<T*>
+ return seed;
+ }
+
+ //
+ // boost::hash
+ //
+
+ template <class T> struct hash
{
- std::size_t operator()(T* v) const
- {
-#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
- return boost::hash_value(v);
-#else
- std::size_t x = static_cast<std::size_t>(
- reinterpret_cast<std::ptrdiff_t>(v));
+ typedef T argument_type;
+ typedef std::size_t result_type;
- return x + (x >> 3);
-#endif
+ std::size_t operator()( T const& val ) const
+ {
+ return hash_value( val );
}
};
-#else
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ( \
+ ( defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION < 142 ) || \
+ ( !defined(_MSVC_STL_VERSION) && defined(_CPPLIB_VER) && _CPPLIB_VER >= 520 ) )
- // For compilers without partial specialization, we define a
- // boost::hash for all remaining types. But hash_impl is only defined
- // for pointers in 'extensions.hpp' - so when BOOST_HASH_NO_EXTENSIONS
- // is defined there will still be a compile error for types not supported
- // in the standard.
+ // Dinkumware has stdext::hash_value for basic_string in <xhash> :-/
- namespace hash_detail
+ template<class E, class T, class A> struct hash< std::basic_string<E, T, A> >
{
- template <bool IsPointer>
- struct hash_impl;
+ typedef std::basic_string<E, T, A> argument_type;
+ typedef std::size_t result_type;
- template <>
- struct hash_impl<true>
+ std::size_t operator()( std::basic_string<E, T, A> const& val ) const
{
- template <class T>
- struct inner
- : public boost::hash_detail::hash_base<T>
- {
- std::size_t operator()(T val) const
- {
-#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 590)
- return boost::hash_value(val);
-#else
- std::size_t x = static_cast<std::size_t>(
- reinterpret_cast<std::ptrdiff_t>(val));
+ return boost::hash_value( val );
+ }
+ };
- return x + (x >> 3);
#endif
- }
- };
- };
- }
- template <class T> struct hash
- : public boost::hash_detail::hash_impl<boost::is_pointer<T>::value>
- ::BOOST_NESTED_TEMPLATE inner<T>
+ // boost::unordered::hash_is_avalanching
+
+ namespace unordered
{
- };
+ template<class T> struct hash_is_avalanching;
+ template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: boost::is_integral<Ch> {};
+ // boost::is_integral<char8_t> is false, but should be true (https://github.com/boostorg/type_traits/issues/175)
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+ template<> struct hash_is_avalanching< boost::hash< std::basic_string<char8_t> > >: boost::true_type {};
#endif
-}
-#undef BOOST_HASH_CHAR_TRAITS
-#undef BOOST_FUNCTIONAL_HASH_ROTL32
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+ template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: boost::is_integral<Ch> {};
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+ template<> struct hash_is_avalanching< boost::hash< std::basic_string_view<char8_t> > >: boost::true_type {};
#endif
-#endif // BOOST_FUNCTIONAL_HASH_HASH_HPP
+#endif
+ } // namespace unordered
-// Include this outside of the include guards in case the file is included
-// twice - once with BOOST_HASH_NO_EXTENSIONS defined, and then with it
-// undefined.
+} // namespace boost
-#if !defined(BOOST_HASH_NO_EXTENSIONS) \
- && !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
-#include <boost/container_hash/extensions.hpp>
-#endif
+#endif // #ifndef BOOST_FUNCTIONAL_HASH_HASH_HPP
-
// Copyright 2005-2009 Daniel James.
-// 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)
-
-// Based on Peter Dimov's proposal
-// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
-// issue 6.18.
+// Copyright 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
-#if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP)
+#ifndef BOOST_FUNCTIONAL_HASH_FWD_HPP
#define BOOST_FUNCTIONAL_HASH_FWD_HPP
-#include <boost/config/workaround.hpp>
#include <cstddef>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-
namespace boost
{
- template <class T> struct hash;
- template <class T> void hash_combine(std::size_t& seed, T const& v);
+namespace container_hash
+{
+
+template<class T> struct is_range;
+template<class T> struct is_contiguous_range;
+template<class T> struct is_unordered_range;
+template<class T> struct is_described_class;
+
+} // namespace container_hash
+
+template<class T> struct hash;
+
+template<class T> void hash_combine( std::size_t& seed, T const& v );
+
+template<class It> void hash_range( std::size_t&, It, It );
+template<class It> std::size_t hash_range( It, It );
- template <class It> std::size_t hash_range(It, It);
- template <class It> void hash_range(std::size_t&, It, It);
+template<class It> void hash_unordered_range( std::size_t&, It, It );
+template<class It> std::size_t hash_unordered_range( It, It );
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
- template <class T> inline std::size_t hash_range(T*, T*);
- template <class T> inline void hash_range(std::size_t&, T*, T*);
-#endif
-}
+} // namespace boost
-#endif
+#endif // #ifndef BOOST_FUNCTIONAL_HASH_FWD_HPP
--- /dev/null
+// Copyright 2017, 2018 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
+#define BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
+
+#include <boost/container_hash/is_range.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700) && !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
+
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/declval.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <iterator>
+
+namespace boost
+{
+namespace hash_detail
+{
+
+template<class It, class T, class S>
+ integral_constant< bool, is_same<typename std::iterator_traits<It>::value_type, T>::value && is_integral<S>::value >
+ is_contiguous_range_check( It first, It last, T const*, T const*, S );
+
+template<class T> decltype( is_contiguous_range_check( declval<T const&>().begin(), declval<T const&>().end(), declval<T const&>().data(), declval<T const&>().data() + declval<T const&>().size(), declval<T const&>().size() ) ) is_contiguous_range_( int );
+template<class T> false_type is_contiguous_range_( ... );
+
+template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguous_range_<T>( 0 ) )
+{
+};
+
+} // namespace hash_detail
+
+namespace container_hash
+{
+
+template<class T> struct is_contiguous_range: integral_constant< bool, is_range<T>::value && hash_detail::is_contiguous_range<T>::value >
+{
+};
+
+} // namespace container_hash
+} // namespace boost
+
+#else // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
+
+#include <cstddef>
+#include <vector>
+#include <string>
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+#include <array>
+#endif
+
+namespace boost
+{
+namespace container_hash
+{
+
+template<class T> struct is_contiguous_range: false_type
+{
+};
+
+template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> >: true_type
+{
+};
+
+template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> const >: true_type
+{
+};
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+
+template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> >: true_type
+{
+};
+
+template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> const >: true_type
+{
+};
+
+#endif
+
+} // namespace container_hash
+} // namespace boost
+
+#endif // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
+
+#endif // #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
--- /dev/null
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
+#define BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_union.hpp>
+#include <boost/describe/bases.hpp>
+#include <boost/describe/members.hpp>
+
+namespace boost
+{
+namespace container_hash
+{
+
+#if defined(BOOST_DESCRIBE_CXX11)
+
+template<class T> struct is_described_class: boost::integral_constant<bool,
+ describe::has_describe_bases<T>::value &&
+ describe::has_describe_members<T>::value &&
+ !boost::is_union<T>::value>
+{
+};
+
+#else
+
+template<class T> struct is_described_class: boost::false_type
+{
+};
+
+#endif
+
+} // namespace container_hash
+} // namespace boost
+
+#endif // #ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
--- /dev/null
+// Copyright 2017 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED
+#define BOOST_HASH_IS_RANGE_HPP_INCLUDED
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/declval.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <iterator>
+
+namespace boost
+{
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
+namespace hash_detail
+{
+
+template<class T, class It>
+ integral_constant< bool, !is_same<typename remove_cv<T>::type, typename std::iterator_traits<It>::value_type>::value >
+ is_range_check( It first, It last );
+
+template<class T> decltype( is_range_check<T>( declval<T const&>().begin(), declval<T const&>().end() ) ) is_range_( int );
+template<class T> false_type is_range_( ... );
+
+} // namespace hash_detail
+
+namespace container_hash
+{
+
+template<class T> struct is_range: decltype( hash_detail::is_range_<T>( 0 ) )
+{
+};
+
+} // namespace container_hash
+
+#else
+
+namespace hash_detail
+{
+
+template<class T, class E = true_type> struct is_range_: false_type
+{
+};
+
+template<class T> struct is_range_< T, integral_constant< bool,
+ is_same<typename T::value_type, typename std::iterator_traits<typename T::const_iterator>::value_type>::value &&
+ is_integral<typename T::size_type>::value
+ > >: true_type
+{
+};
+
+} // namespace hash_detail
+
+namespace container_hash
+{
+
+template<class T> struct is_range: hash_detail::is_range_<T>
+{
+};
+
+} // namespace container_hash
+
+#endif // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
+
+} // namespace boost
+
+#endif // #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED
--- /dev/null
+// Copyright 2017 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
+#define BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
+
+#include <boost/container_hash/is_range.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost
+{
+namespace hash_detail
+{
+
+template<class T, class E = true_type> struct has_hasher_: false_type
+{
+};
+
+template<class T> struct has_hasher_< T, integral_constant< bool,
+ is_same<typename T::hasher, typename T::hasher>::value
+ > >: true_type
+{
+};
+
+} // namespace hash_detail
+
+namespace container_hash
+{
+
+template<class T> struct is_unordered_range: integral_constant< bool, is_range<T>::value && hash_detail::has_hasher_<T>::value >
+{
+};
+
+} // namespace container_hash
+} // namespace boost
+
+#endif // #ifndef BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
BOOST_FORCEINLINE T*
addressof(T& o) BOOST_NOEXCEPT
{
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) || \
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) || \
BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120)
return boost::detail::addrof<T>::get(o, 0);
#else
}
#endif
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
template<class T, std::size_t N>
BOOST_FORCEINLINE
T (*addressof(T (&o)[N]) BOOST_NOEXCEPT)[N]
#include <boost/core/enable_if.hpp>
#include <boost/config.hpp>
-#include <utility> //for std::swap (C++11)
-#include <algorithm> //for std::swap (C++98)
-#include <cstddef> //for std::size_t
+#if __cplusplus >= 201103L || defined(BOOST_DINKUMWARE_STDLIB)
+#include <utility> // for std::swap (C++11)
+#else
+#include <algorithm> // for std::swap (C++98)
+#endif
+#include <cstddef> // for std::size_t
namespace boost_swap_impl
{
remainder ^= ( new_dividend_bits & 1u ) ? high_bit_mask : 0u;
// perform modulo-2 division
- bool const quotient = remainder & high_bit_mask;
+ bool const quotient = (remainder & high_bit_mask) != 0;
remainder <<= 1;
remainder ^= quotient ? truncated_divisor : 0u;
// Perform modulo-2 division for each new dividend input bit
for ( int i = word_length ; i ; --i, new_dividend_bits >>= 1 )
{
- bool const quotient = remainder & high_bit_mask;
+ bool const quotient = (remainder & high_bit_mask) != 0;
remainder <<= 1;
remainder |= new_dividend_bits & 1u;
unsigned char const high_bit_mask = 1u << ( CHAR_BIT - 1u );
for ( std::size_t i = bit_length ; i > 0u ; --i, bits <<= 1u )
{
- process_bit( static_cast<bool>(bits & high_bit_mask) );
+ process_bit( (bits & high_bit_mask) != 0 );
}
}
// 64-bit types + intmax_t and uintmax_t ----------------------------------//
# if defined(BOOST_HAS_LONG_LONG) && \
- !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
+ !defined(BOOST_MSVC) && !defined(BOOST_BORLANDC) && \
(!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
(defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
# if defined(__hpux)
#ifndef INT64_C
# define INT64_C(value) value##i64
#endif
-# ifdef __BORLANDC__
+# ifdef BOOST_BORLANDC
// Borland bug: appending ui8 makes the type a signed char
# define UINT8_C(value) static_cast<unsigned char>(value##u)
# else
--- /dev/null
+#ifndef BOOST_DESCRIBE_BASES_HPP_INCLUDED
+#define BOOST_DESCRIBE_BASES_HPP_INCLUDED
+
+// Copyright 2020, 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/describe/modifiers.hpp>
+#include <boost/describe/detail/void_t.hpp>
+#include <boost/describe/detail/config.hpp>
+
+#if defined(BOOST_DESCRIBE_CXX11)
+
+#include <boost/mp11/algorithm.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace describe
+{
+namespace detail
+{
+
+template<class T> using _describe_bases = decltype( boost_base_descriptor_fn( static_cast<T**>(0) ) );
+
+template<unsigned M> struct base_filter
+{
+ template<class T> using fn = mp11::mp_bool< ( M & mod_any_access & T::modifiers ) != 0 >;
+};
+
+template<class T, class En = void> struct has_describe_bases: std::false_type
+{
+};
+
+template<class T> struct has_describe_bases<T, void_t<_describe_bases<T>>>: std::true_type
+{
+};
+
+} // namespace detail
+
+template<class T, unsigned M> using describe_bases = mp11::mp_copy_if_q<detail::_describe_bases<T>, detail::base_filter<M>>;
+
+template<class T> using has_describe_bases = detail::has_describe_bases<T>;
+
+} // namespace describe
+} // namespace boost
+
+#endif // !defined(BOOST_DESCRIBE_CXX11)
+
+#endif // #ifndef BOOST_DESCRIBE_BASES_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_DESCRIBE_DETAIL_CONFIG_HPP_INCLUDED
+#define BOOST_DESCRIBE_DETAIL_CONFIG_HPP_INCLUDED
+
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if __cplusplus >= 201402L
+
+# define BOOST_DESCRIBE_CXX14
+# define BOOST_DESCRIBE_CXX11
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1900
+
+# define BOOST_DESCRIBE_CXX14
+# define BOOST_DESCRIBE_CXX11
+
+#elif __cplusplus >= 201103L
+
+# define BOOST_DESCRIBE_CXX11
+
+# if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 7
+# undef BOOST_DESCRIBE_CXX11
+# endif
+
+#endif
+
+#if defined(BOOST_DESCRIBE_CXX11)
+# define BOOST_DESCRIBE_CONSTEXPR_OR_CONST constexpr
+#else
+# define BOOST_DESCRIBE_CONSTEXPR_OR_CONST const
+#endif
+
+#if defined(__clang__)
+# define BOOST_DESCRIBE_MAYBE_UNUSED __attribute__((unused))
+#else
+# define BOOST_DESCRIBE_MAYBE_UNUSED
+#endif
+
+#endif // #ifndef BOOST_DESCRIBE_DETAIL_CONFIG_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_DESCRIBE_DETAIL_CX_STREQ_HPP_INCLUDED
+#define BOOST_DESCRIBE_DETAIL_CX_STREQ_HPP_INCLUDED
+
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/describe/detail/config.hpp>
+
+#if defined(BOOST_DESCRIBE_CXX11)
+
+namespace boost
+{
+namespace describe
+{
+namespace detail
+{
+
+constexpr bool cx_streq( char const * s1, char const * s2 )
+{
+ return s1[0] == s2[0] && ( s1[0] == 0 || cx_streq( s1 + 1, s2 + 1 ) );
+}
+
+} // namespace detail
+} // namespace describe
+} // namespace boost
+
+#endif // defined(BOOST_DESCRIBE_CXX11)
+
+#endif // #ifndef BOOST_DESCRIBE_DETAIL_CX_STREQ_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_DESCRIBE_DETAIL_VOID_T_HPP_INCLUDED
+#define BOOST_DESCRIBE_DETAIL_VOID_T_HPP_INCLUDED
+
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/describe/detail/config.hpp>
+
+#if defined(BOOST_DESCRIBE_CXX11)
+
+namespace boost
+{
+namespace describe
+{
+namespace detail
+{
+
+template<class...> struct make_void
+{
+ using type = void;
+};
+
+template<class... T> using void_t = typename make_void<T...>::type;
+
+} // namespace detail
+} // namespace describe
+} // namespace boost
+
+#endif // defined(BOOST_DESCRIBE_CXX11)
+
+#endif // #ifndef BOOST_DESCRIBE_DETAIL_VOID_T_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_DESCRIBE_DATA_MEMBERS_HPP_INCLUDED
+#define BOOST_DESCRIBE_DATA_MEMBERS_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/describe/modifiers.hpp>
+#include <boost/describe/bases.hpp>
+#include <boost/describe/detail/void_t.hpp>
+#include <boost/describe/detail/cx_streq.hpp>
+#include <boost/describe/detail/config.hpp>
+
+#if defined(BOOST_DESCRIBE_CXX11)
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/bind.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace describe
+{
+namespace detail
+{
+
+// _describe_members<T>
+
+template<class T> using _describe_public_members = decltype( boost_public_member_descriptor_fn( static_cast<T**>(0) ) );
+template<class T> using _describe_protected_members = decltype( boost_protected_member_descriptor_fn( static_cast<T**>(0) ) );
+template<class T> using _describe_private_members = decltype( boost_private_member_descriptor_fn( static_cast<T**>(0) ) );
+
+template<class T> using _describe_members = mp11::mp_append<_describe_public_members<T>, _describe_protected_members<T>, _describe_private_members<T>>;
+
+// describe_inherited_members<T>
+
+// T: type
+// V: list of virtual bases visited so far
+template<class T, class V> struct describe_inherited_members_impl;
+template<class T, class V> using describe_inherited_members = typename describe_inherited_members_impl<T, V>::type;
+
+// L: list of base class descriptors
+// T: derived type
+// V: list of virtual bases visited so far
+template<class L, class T, class V> struct describe_inherited_members2_impl;
+template<class L, class T, class V> using describe_inherited_members2 = typename describe_inherited_members2_impl<L, T, V>::type;
+
+template<class T, class V> struct describe_inherited_members_impl
+{
+ using R1 = describe_inherited_members2<describe_bases<T, mod_any_access>, T, V>;
+ using R2 = _describe_members<T>;
+
+ using type = mp11::mp_append<R1, R2>;
+};
+
+template<template<class...> class L, class T, class V> struct describe_inherited_members2_impl<L<>, T, V>
+{
+ using type = L<>;
+};
+
+template<class D1, class D2> using name_matches = mp11::mp_bool< cx_streq( D1::name, D2::name ) >;
+
+template<class D, class L> using name_is_hidden = mp11::mp_any_of_q<L, mp11::mp_bind_front<name_matches, D>>;
+
+constexpr unsigned cx_max( unsigned m1, unsigned m2 )
+{
+ return m1 > m2? m1: m2;
+}
+
+template<class T, unsigned Bm> struct update_modifiers
+{
+ template<class D> struct fn
+ {
+ using L = _describe_members<T>;
+ static constexpr unsigned hidden = name_is_hidden<D, L>::value? mod_hidden: 0;
+
+ static constexpr unsigned mods = D::modifiers;
+ static constexpr unsigned access = cx_max( mods & mod_any_access, Bm & mod_any_access );
+
+ static constexpr decltype(D::pointer) pointer = D::pointer;
+ static constexpr decltype(D::name) name = D::name;
+ static constexpr unsigned modifiers = ( mods & ~mod_any_access ) | access | mod_inherited | hidden;
+ };
+};
+
+template<class T, unsigned Bm> template<class D> constexpr decltype(D::pointer) update_modifiers<T, Bm>::fn<D>::pointer;
+template<class T, unsigned Bm> template<class D> constexpr decltype(D::name) update_modifiers<T, Bm>::fn<D>::name;
+template<class T, unsigned Bm> template<class D> constexpr unsigned update_modifiers<T, Bm>::fn<D>::modifiers;
+
+template<class D> struct gather_virtual_bases_impl;
+template<class D> using gather_virtual_bases = typename gather_virtual_bases_impl<D>::type;
+
+template<class D> struct gather_virtual_bases_impl
+{
+ using B = typename D::type;
+ static constexpr unsigned M = D::modifiers;
+
+ using R1 = mp11::mp_transform<gather_virtual_bases, describe_bases<B, mod_any_access>>;
+ using R2 = mp11::mp_apply<mp11::mp_append, R1>;
+
+ using type = mp11::mp_if_c<(M & mod_virtual) != 0, mp11::mp_push_front<R2, B>, R2>;
+};
+
+template<template<class...> class L, class D1, class... D, class T, class V> struct describe_inherited_members2_impl<L<D1, D...>, T, V>
+{
+ using B = typename D1::type;
+ static constexpr unsigned M = D1::modifiers;
+
+ using R1 = mp11::mp_if_c<(M & mod_virtual) && mp11::mp_contains<V, B>::value, L<>, describe_inherited_members<B, V>>;
+
+ using R2 = mp11::mp_transform_q<update_modifiers<T, M>, R1>;
+
+ using V2 = mp11::mp_append<V, gather_virtual_bases<D1>>;
+ using R3 = describe_inherited_members2<L<D...>, T, V2>;
+
+ using type = mp11::mp_append<R2, R3>;
+};
+
+// describe_members<T, M>
+
+template<class T, unsigned M> using describe_members = mp11::mp_eval_if_c<(M & mod_inherited) == 0, _describe_members<T>, describe_inherited_members, T, mp11::mp_list<>>;
+
+// member_filter
+
+template<unsigned M> struct member_filter
+{
+ template<class T> using fn = mp11::mp_bool<
+ (M & mod_any_access & T::modifiers) != 0 &&
+ ( (M & mod_any_member) != 0 || (M & mod_static) == (T::modifiers & mod_static) ) &&
+ ( (M & mod_any_member) != 0 || (M & mod_function) == (T::modifiers & mod_function) ) &&
+ (M & mod_hidden) >= (T::modifiers & mod_hidden)
+ >;
+};
+
+// has_describe_members
+
+template<class T, class En = void> struct has_describe_members: std::false_type
+{
+};
+
+template<class T> struct has_describe_members<T, void_t<_describe_members<T>>>: std::true_type
+{
+};
+
+} // namespace detail
+
+template<class T, unsigned M> using describe_members = mp11::mp_copy_if_q<detail::describe_members<T, M>, detail::member_filter<M>>;
+
+template<class T> using has_describe_members = detail::has_describe_members<T>;
+
+} // namespace describe
+} // namespace boost
+
+#endif // !defined(BOOST_DESCRIBE_CXX11)
+
+#endif // #ifndef BOOST_DESCRIBE_DATA_MEMBERS_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_DESCRIBE_MODIFIERS_HPP_INCLUDED
+#define BOOST_DESCRIBE_MODIFIERS_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/describe/detail/config.hpp>
+
+namespace boost
+{
+namespace describe
+{
+
+enum modifiers
+{
+ mod_public = 1,
+ mod_protected = 2,
+ mod_private = 4,
+ mod_virtual = 8,
+ mod_static = 16,
+ mod_function = 32,
+ mod_any_member = 64,
+ mod_inherited = 128,
+ mod_hidden = 256
+};
+
+BOOST_DESCRIBE_CONSTEXPR_OR_CONST modifiers mod_any_access = static_cast<modifiers>( mod_public | mod_protected | mod_private );
+
+} // namespace describe
+} // namespace boost
+
+#endif // #ifndef BOOST_DESCRIBE_MODIFIERS_HPP_INCLUDED
+++ /dev/null
-
-// Copyright 2005-2011 Daniel James.
-// 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)
-
-// Note: if you change this include guard, you also need to change
-// container_fwd_compile_fail.cpp
-#if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP)
-#define BOOST_DETAIL_CONTAINER_FWD_HPP
-
-#if defined(_MSC_VER) && \
- !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-////////////////////////////////////////////////////////////////////////////////
-// //
-// Define BOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to //
-// forward declare standard containers. //
-// //
-// BOOST_DETAIL_CONTAINER_FWD to make it foward declare containers even if it //
-// normally doesn't. //
-// //
-// BOOST_DETAIL_NO_CONTAINER_FWD overrides BOOST_DETAIL_CONTAINER_FWD. //
-// //
-////////////////////////////////////////////////////////////////////////////////
-
-#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
-# if defined(BOOST_DETAIL_CONTAINER_FWD)
- // Force forward declarations.
-# elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
- // STLport
-# define BOOST_DETAIL_NO_CONTAINER_FWD
-# elif defined(__LIBCOMO__)
- // Comeau STL:
-# define BOOST_DETAIL_NO_CONTAINER_FWD
-# elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
- // Rogue Wave library:
-# define BOOST_DETAIL_NO_CONTAINER_FWD
-# elif defined(_LIBCPP_VERSION)
- // libc++
-# define BOOST_DETAIL_NO_CONTAINER_FWD
-# elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
- // GNU libstdc++ 3
- //
- // Disable forwarding for all recent versions, as the library has a
- // versioned namespace mode, and I don't know how to detect it.
-# if __GLIBCXX__ >= 20070513 \
- || defined(_GLIBCXX_DEBUG) \
- || defined(_GLIBCXX_PARALLEL) \
- || defined(_GLIBCXX_PROFILE)
-# define BOOST_DETAIL_NO_CONTAINER_FWD
-# else
-# if defined(__GLIBCXX__) && __GLIBCXX__ >= 20040530
-# define BOOST_CONTAINER_FWD_COMPLEX_STRUCT
-# endif
-# endif
-# elif defined(__STL_CONFIG_H)
- // generic SGI STL
- //
- // Forward declaration seems to be okay, but it has a couple of odd
- // implementations.
-# define BOOST_CONTAINER_FWD_BAD_BITSET
-# if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
-# define BOOST_CONTAINER_FWD_BAD_DEQUE
-# endif
-# elif defined(__MSL_CPP__)
- // MSL standard lib:
-# define BOOST_DETAIL_NO_CONTAINER_FWD
-# elif defined(__IBMCPP__)
- // The default VACPP std lib, forward declaration seems to be fine.
-# elif defined(MSIPL_COMPILE_H)
- // Modena C++ standard library
-# define BOOST_DETAIL_NO_CONTAINER_FWD
-# elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
- // Dinkumware Library (this has to appear after any possible replacement
- // libraries)
-# else
-# define BOOST_DETAIL_NO_CONTAINER_FWD
-# endif
-#endif
-
-#if !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
-
-#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) && \
- !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
-
-#include <deque>
-#include <list>
-#include <vector>
-#include <map>
-#include <set>
-#include <bitset>
-#include <string>
-#include <complex>
-
-#else
-
-#include <cstddef>
-
-#if defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
-#include <deque>
-#endif
-
-#if defined(BOOST_CONTAINER_FWD_BAD_BITSET)
-#include <bitset>
-#endif
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4099) // struct/class mismatch in fwd declarations
-#endif
-
-namespace std
-{
- template <class T> class allocator;
- template <class charT, class traits, class Allocator> class basic_string;
-
- template <class charT> struct char_traits;
-
-#if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT)
- template <class T> struct complex;
-#else
- template <class T> class complex;
-#endif
-
-#if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
- template <class T, class Allocator> class deque;
-#endif
-
- template <class T, class Allocator> class list;
- template <class T, class Allocator> class vector;
- template <class Key, class T, class Compare, class Allocator> class map;
- template <class Key, class T, class Compare, class Allocator>
- class multimap;
- template <class Key, class Compare, class Allocator> class set;
- template <class Key, class Compare, class Allocator> class multiset;
-
-#if !defined(BOOST_CONTAINER_FWD_BAD_BITSET)
- template <size_t N> class bitset;
-#endif
- template <class T1, class T2> struct pair;
-}
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_DETAIL_NO_CONTAINER_FWD &&
- // !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
-
-#endif // BOOST_DETAIL_TEST_CONFIG_ONLY
-
-#endif
+++ /dev/null
-// (C) Copyright David Abrahams 2002.
-// 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 ITERATOR_DWA122600_HPP_
-#define ITERATOR_DWA122600_HPP_
-
-// This header is obsolete and will be deprecated.
-
-#include <iterator>
-#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
-#include <cstddef>
-#endif
-
-namespace boost
-{
-
-namespace detail
-{
-
-using std::iterator_traits;
-using std::distance;
-
-#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
-// std::distance from stlport with Oracle compiler 12.4 and 12.5 fails to deduce template parameters
-// when one of the arguments is an array and the other one is a pointer.
-template< typename T, std::size_t N >
-inline typename std::iterator_traits< T* >::difference_type distance(T (&left)[N], T* right)
-{
- return std::distance(static_cast< T* >(left), right);
-}
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // ITERATOR_DWA122600_HPP_
// 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 WORKAROUND_DWA2002126_HPP
-#define WORKAROUND_DWA2002126_HPP
+#ifndef BOOST_WORKAROUND_DWA2002126_HPP
+#define BOOST_WORKAROUND_DWA2002126_HPP
#include <boost/config/workaround.hpp>
-#endif // WORKAROUND_DWA2002126_HPP
+#endif // BOOST_WORKAROUND_DWA2002126_HPP
//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 UUID_274DA366004E11DCB1DDFE2E56D89593
-#define UUID_274DA366004E11DCB1DDFE2E56D89593
+#ifndef BOOST_EXCEPTION_274DA366004E11DCB1DDFE2E56D89593
+#define BOOST_EXCEPTION_274DA366004E11DCB1DDFE2E56D89593
+#include <boost/assert/source_location.hpp>
#include <boost/config.hpp>
+#include <exception>
#ifdef BOOST_EXCEPTION_MINI_BOOST
#include <memory>
namespace boost { namespace exception_detail { using boost::shared_ptr; } }
#endif
-#if defined(__GNUC__) && (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#if !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#ifdef __clang__
+#pragma clang system_header
+#endif
+#ifdef _MSC_VER
#pragma warning(push,1)
#pragma warning(disable: 4265)
#endif
+#endif
namespace
boost
typedef error_info<struct throw_function_,char const *> throw_function;
typedef error_info<struct throw_file_,char const *> throw_file;
typedef error_info<struct throw_line_,int> throw_line;
+ typedef error_info<struct throw_column_,int> throw_column;
template <>
class
}
};
+ template <>
+ class
+ error_info<throw_column_,int>
+ {
+ public:
+ typedef int value_type;
+ value_type v_;
+ explicit
+ error_info( value_type v ):
+ v_(v)
+ {
+ }
+ };
+
class
BOOST_SYMBOL_VISIBLE
exception;
template <>
struct get_info<throw_line>;
+ template <>
+ struct get_info<throw_column>;
+
template <class>
struct set_info_rv;
template <>
struct set_info_rv<throw_line>;
+ template <>
+ struct set_info_rv<throw_column>;
+
char const * get_diagnostic_information( exception const &, char const * );
void copy_boost_exception( exception *, exception const * );
template <class E>
E const & set_info( E const &, throw_line const & );
+
+ template <class E>
+ E const & set_info( E const &, throw_column const & );
+
+ boost::source_location get_exception_throw_location( exception const & );
}
class
exception():
throw_function_(0),
throw_file_(0),
- throw_line_(-1)
+ throw_line_(-1),
+ throw_column_(-1)
{
}
data_(x.data_),
throw_function_(x.throw_function_),
throw_file_(x.throw_file_),
- throw_line_(x.throw_line_)
+ throw_line_(x.throw_line_),
+ throw_column_(x.throw_column_)
{
}
#endif
template <class E>
friend E const & exception_detail::set_info( E const &, throw_line const & );
+ template <class E>
+ friend E const & exception_detail::set_info( E const &, throw_column const & );
+
template <class E,class Tag,class T>
friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
+ friend boost::source_location exception_detail::get_exception_throw_location( exception const & );
+
template <class>
friend struct exception_detail::get_info;
friend struct exception_detail::get_info<throw_function>;
friend struct exception_detail::get_info<throw_file>;
friend struct exception_detail::get_info<throw_line>;
+ friend struct exception_detail::get_info<throw_column>;
template <class>
friend struct exception_detail::set_info_rv;
friend struct exception_detail::set_info_rv<throw_function>;
friend struct exception_detail::set_info_rv<throw_file>;
friend struct exception_detail::set_info_rv<throw_line>;
+ friend struct exception_detail::set_info_rv<throw_column>;
friend void exception_detail::copy_boost_exception( exception *, exception const * );
#endif
mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
mutable char const * throw_function_;
mutable char const * throw_file_;
mutable int throw_line_;
+ mutable int throw_column_;
};
inline
x.throw_line_=y.v_;
return x;
}
+
+ template <class E>
+ E const &
+ set_info( E const & x, throw_column const & y )
+ {
+ x.throw_column_=y.v_;
+ return x;
+ }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+ template <>
+ struct
+ set_info_rv<throw_column>
+ {
+ template <class E>
+ static
+ E const &
+ set( E const & x, throw_column && y )
+ {
+ x.throw_column_=y.v_;
+ return x;
+ }
+ };
+
+#endif
+
+ inline boost::source_location get_exception_throw_location( exception const & x )
+ {
+ return boost::source_location(
+ x.throw_file_? x.throw_file_: "",
+ x.throw_line_ >= 0? x.throw_line_: 0,
+ x.throw_function_? x.throw_function_: "",
+ x.throw_column_ >= 0? x.throw_column_: 0
+ );
+ }
}
////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////
+#if defined(BOOST_NO_EXCEPTIONS)
+ BOOST_NORETURN void throw_exception(std::exception const & e); // user defined
+#endif
namespace
exception_detail
a->throw_file_ = b->throw_file_;
a->throw_line_ = b->throw_line_;
a->throw_function_ = b->throw_function_;
+ a->throw_column_ = b->throw_column_;
a->data_ = data;
}
void
rethrow() const
{
+#if defined(BOOST_NO_EXCEPTIONS)
+ boost::throw_exception(*this);
+#else
throw*this;
+#endif
}
};
}
{
return exception_detail::clone_impl<T>(x);
}
-
- template <class T>
- struct
- BOOST_SYMBOL_VISIBLE
- wrapexcept:
- public exception_detail::clone_impl<typename exception_detail::enable_error_info_return_type<T>::type>
- {
- typedef exception_detail::clone_impl<typename exception_detail::enable_error_info_return_type<T>::type> base_type;
- public:
- explicit
- wrapexcept( typename exception_detail::enable_error_info_return_type<T>::type const & x ):
- base_type( x )
- {
- }
-
- ~wrapexcept() BOOST_NOEXCEPT_OR_NOTHROW
- {
- }
- };
-
- namespace
- exception_detail
- {
- template <class T>
- struct
- remove_error_info_injector
- {
- typedef T type;
- };
-
- template <class T>
- struct
- remove_error_info_injector< error_info_injector<T> >
- {
- typedef T type;
- };
-
- template <class T>
- inline
- wrapexcept<typename remove_error_info_injector<T>::type>
- enable_both( T const & x )
- {
- return wrapexcept<typename remove_error_info_injector<T>::type>( enable_error_info( x ) );
- }
- }
}
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma warning(pop)
#endif
-#endif
+
+#endif // #ifndef BOOST_EXCEPTION_274DA366004E11DCB1DDFE2E56D89593
// Copyright Beman Dawes and Daryle Walker 1999. 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)
+// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
-// See http://www.boost.org/libs/integer for documentation.
+// See https://www.boost.org/libs/integer for documentation.
// Revision History
// 22 Sep 01 Added value-based integer templates. (Daryle Walker)
{
BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::uintmax_t) * CHAR_BIT),
"No suitable unsigned integer type with the requested number of bits is available.");
-#if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
+#if (defined(BOOST_BORLANDC) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
// It's really not clear why this workaround should be needed... shrug I guess! JM
BOOST_STATIC_CONSTANT(int, s =
6 +
#endif
struct uint_value_t
{
-#if (defined(__BORLANDC__) || defined(__CODEGEAR__))
+#if (defined(BOOST_BORLANDC) || defined(__CODEGEAR__))
// It's really not clear why this workaround should be needed... shrug I guess! JM
#if defined(BOOST_NO_INTEGRAL_INT64_T)
BOOST_STATIC_CONSTANT(unsigned, which =
+++ /dev/null
-// -------------- Boost static_log2.hpp header file ----------------------- //
-//
-// Copyright (C) 2001 Daryle Walker.
-// Copyright (C) 2003 Vesa Karvonen.
-// Copyright (C) 2003 Gennaro Prota.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// ---------------------------------------------------
-// See http://www.boost.org/libs/integer for documentation.
-// ------------------------------------------------------------------------- //
-
-
-#ifndef BOOST_INTEGER_STATIC_LOG2_HPP
-#define BOOST_INTEGER_STATIC_LOG2_HPP
-
-#include "boost/integer_fwd.hpp" // for boost::intmax_t
-
-namespace boost {
-
- namespace detail {
-
- namespace static_log2_impl {
-
- // choose_initial_n<>
- //
- // Recursively doubles its integer argument, until it
- // becomes >= of the "width" (C99, 6.2.6.2p4) of
- // static_log2_argument_type.
- //
- // Used to get the maximum power of two less then the width.
- //
- // Example: if on your platform argument_type has 48 value
- // bits it yields n=32.
- //
- // It's easy to prove that, starting from such a value
- // of n, the core algorithm works correctly for any width
- // of static_log2_argument_type and that recursion always
- // terminates with x = 1 and n = 0 (see the algorithm's
- // invariant).
-
- typedef boost::static_log2_argument_type argument_type;
- typedef boost::static_log2_result_type result_type;
-
- template <result_type n>
- struct choose_initial_n {
-
- BOOST_STATIC_CONSTANT(bool, c = (argument_type(1) << n << n) != 0);
- BOOST_STATIC_CONSTANT(
- result_type,
- value = !c*n + choose_initial_n<2*c*n>::value
- );
-
- };
-
- template <>
- struct choose_initial_n<0> {
- BOOST_STATIC_CONSTANT(result_type, value = 0);
- };
-
-
-
- // start computing from n_zero - must be a power of two
- const result_type n_zero = 16;
- const result_type initial_n = choose_initial_n<n_zero>::value;
-
- // static_log2_impl<>
- //
- // * Invariant:
- // 2n
- // 1 <= x && x < 2 at the start of each recursion
- // (see also choose_initial_n<>)
- //
- // * Type requirements:
- //
- // argument_type maybe any unsigned type with at least n_zero + 1
- // value bits. (Note: If larger types will be standardized -e.g.
- // unsigned long long- then the argument_type typedef can be
- // changed without affecting the rest of the code.)
- //
-
- template <argument_type x, result_type n = initial_n>
- struct static_log2_impl {
-
- BOOST_STATIC_CONSTANT(bool, c = (x >> n) > 0); // x >= 2**n ?
- BOOST_STATIC_CONSTANT(
- result_type,
- value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
- );
-
- };
-
- template <>
- struct static_log2_impl<1, 0> {
- BOOST_STATIC_CONSTANT(result_type, value = 0);
- };
-
- }
- } // detail
-
-
-
- // --------------------------------------
- // static_log2<x>
- // ----------------------------------------
-
- template <static_log2_argument_type x>
- struct static_log2 {
-
- BOOST_STATIC_CONSTANT(
- static_log2_result_type,
- value = detail::static_log2_impl::static_log2_impl<x>::value
- );
-
- };
-
-
- template <>
- struct static_log2<0> { };
-
-}
-
-
-
-#endif // include guard
// (C) Copyright Dave Abrahams and Daryle Walker 2001. 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)
+// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
-// See http://www.boost.org/libs/integer for documentation.
+// See https://www.boost.org/libs/integer for documentation.
#ifndef BOOST_INTEGER_FWD_HPP
#define BOOST_INTEGER_FWD_HPP
* Copyright Jens Maurer 2000
* 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)
+ * https://www.boost.org/LICENSE_1_0.txt)
*
* $Id$
*
* Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
*/
-// See http://www.boost.org/libs/integer for documentation.
+// See https://www.boost.org/libs/integer for documentation.
#ifndef BOOST_INTEGER_TRAITS_HPP
// library: they are wrong!
#if defined(WCHAR_MIN) && defined(WCHAR_MAX) && !defined(__APPLE__)
public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX>
-#elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
+#elif defined(BOOST_BORLANDC) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
// No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned:
public detail::integer_traits_base<wchar_t, 0, 0xffff>
#elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\
--- /dev/null
+#ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
+#define BOOST_MP11_ALGORITHM_HPP_INCLUDED
+
+// Copyright 2015-2019 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
+
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/set.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/detail/mp_count.hpp>
+#include <boost/mp11/detail/mp_plus.hpp>
+#include <boost/mp11/detail/mp_map_find.hpp>
+#include <boost/mp11/detail/mp_with_index.hpp>
+#include <boost/mp11/detail/mp_fold.hpp>
+#include <boost/mp11/detail/mp_min_element.hpp>
+#include <boost/mp11/detail/mp_copy_if.hpp>
+#include <boost/mp11/detail/mp_remove_if.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/mp11/integer_sequence.hpp>
+#include <type_traits>
+#include <utility>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_transform<F, L...>
+namespace detail
+{
+
+template<template<class...> class F, class... L> struct mp_transform_impl
+{
+};
+
+template<template<class...> class F, template<class...> class L, class... T> struct mp_transform_impl<F, L<T...>>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+ template<class... U> struct f { using type = F<U...>; };
+
+ using type = L<typename f<T>::type...>;
+
+#else
+
+ using type = L<F<T>...>;
+
+#endif
+};
+
+template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_transform_impl<F, L1<T1...>, L2<T2...>>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+ template<class... U> struct f { using type = F<U...>; };
+
+ using type = L1<typename f<T1, T2>::type...>;
+
+#else
+
+ using type = L1<F<T1,T2>...>;
+
+#endif
+};
+
+template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+ template<class... U> struct f { using type = F<U...>; };
+
+ using type = L1<typename f<T1, T2, T3>::type...>;
+
+#else
+
+ using type = L1<F<T1,T2,T3>...>;
+
+#endif
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+
+template<class... L> using mp_same_size_1 = mp_same<mp_size<L>...>;
+template<class... L> struct mp_same_size_2: mp_defer<mp_same_size_1, L...> {};
+
+#endif
+
+struct list_size_mismatch
+{
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... L> struct mp_transform_cuda_workaround
+{
+ using type = mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>;
+};
+
+#endif
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+
+template<template<class...> class F, class... L> using mp_transform = typename mp_if<typename detail::mp_same_size_2<L...>::type, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;
+
+#else
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... L> using mp_transform = typename detail::mp_transform_cuda_workaround< F, L...>::type::type;
+
+#else
+
+template<template<class...> class F, class... L> using mp_transform = typename mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;
+
+#endif
+
+#endif
+
+template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;
+
+namespace detail
+{
+
+template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, class... L> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L...>
+{
+ using A1 = L1<mp_list<T1, T2, T3, T4>...>;
+
+ template<class V, class T> using _f = mp_transform<mp_push_back, V, T>;
+
+ using A2 = mp_fold<mp_list<L...>, A1, _f>;
+
+ template<class T> using _g = mp_apply<F, T>;
+
+ using type = mp_transform<_g, A2>;
+};
+
+} // namespace detail
+
+// mp_transform_if<P, F, L...>
+namespace detail
+{
+
+template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
+{
+ // the stupid quote-unquote dance avoids "pack expansion used as argument for non-pack parameter of alias template"
+
+ using Qp = mp_quote<P>;
+ using Qf = mp_quote<F>;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+ template<class... U> struct _f_ { using type = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>; };
+ template<class... U> using _f = typename _f_<U...>::type;
+
+#else
+
+ template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
+
+#endif
+
+ using type = mp_transform<_f, L...>;
+};
+
+} // namespace detail
+
+template<template<class...> class P, template<class...> class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl<P, F, L...>::type;
+template<class Qp, class Qf, class... L> using mp_transform_if_q = typename detail::mp_transform_if_impl<Qp::template fn, Qf::template fn, L...>::type;
+
+// mp_filter<P, L...>
+namespace detail
+{
+
+template<template<class...> class P, class L1, class... L> struct mp_filter_impl
+{
+ using Qp = mp_quote<P>;
+
+ template<class T1, class... T> using _f = mp_if< mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;
+
+ using _t1 = mp_transform<_f, L1, L...>;
+ using _t2 = mp_apply<mp_append, _t1>;
+
+ using type = mp_assign<L1, _t2>;
+};
+
+} // namespace detail
+
+template<template<class...> class P, class... L> using mp_filter = typename detail::mp_filter_impl<P, L...>::type;
+template<class Q, class... L> using mp_filter_q = typename detail::mp_filter_impl<Q::template fn, L...>::type;
+
+// mp_fill<L, V>
+namespace detail
+{
+
+template<class L, class V> struct mp_fill_impl;
+
+template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
+
+ template<class...> struct _f { using type = V; };
+ using type = L<typename _f<T>::type...>;
+
+#else
+
+ template<class...> using _f = V;
+ using type = L<_f<T>...>;
+
+#endif
+};
+
+} // namespace detail
+
+template<class L, class V> using mp_fill = typename detail::mp_fill_impl<L, V>::type;
+
+// mp_contains<L, V>
+template<class L, class V> using mp_contains = mp_to_bool<mp_count<L, V>>;
+
+// mp_repeat(_c)<L, N>
+namespace detail
+{
+
+template<class L, std::size_t N> struct mp_repeat_c_impl
+{
+ using _l1 = typename mp_repeat_c_impl<L, N/2>::type;
+ using _l2 = typename mp_repeat_c_impl<L, N%2>::type;
+
+ using type = mp_append<_l1, _l1, _l2>;
+};
+
+template<class L> struct mp_repeat_c_impl<L, 0>
+{
+ using type = mp_clear<L>;
+};
+
+template<class L> struct mp_repeat_c_impl<L, 1>
+{
+ using type = L;
+};
+
+} // namespace detail
+
+template<class L, std::size_t N> using mp_repeat_c = typename detail::mp_repeat_c_impl<L, N>::type;
+template<class L, class N> using mp_repeat = typename detail::mp_repeat_c_impl<L, std::size_t{ N::value }>::type;
+
+// mp_product<F, L...>
+namespace detail
+{
+
+template<template<class...> class F, class P, class... L> struct mp_product_impl_2
+{
+};
+
+template<template<class...> class F, class P> struct mp_product_impl_2<F, P>
+{
+ using type = mp_list<mp_rename<P, F>>;
+};
+
+template<template<class...> class F, class P, template<class...> class L1, class... T1, class... L> struct mp_product_impl_2<F, P, L1<T1...>, L...>
+{
+ using type = mp_append<typename mp_product_impl_2<F, mp_push_back<P, T1>, L...>::type...>;
+};
+
+template<template<class...> class F, class... L> struct mp_product_impl
+{
+};
+
+template<template<class...> class F> struct mp_product_impl<F>
+{
+ using type = mp_list< F<> >;
+};
+
+template<template<class...> class F, class L1, class... L> struct mp_product_impl<F, L1, L...>
+{
+ using type = mp_assign<L1, typename mp_product_impl_2<F, mp_list<>, L1, L...>::type>;
+};
+
+} // namespace detail
+
+template<template<class...> class F, class... L> using mp_product = typename detail::mp_product_impl<F, L...>::type;
+template<class Q, class... L> using mp_product_q = typename detail::mp_product_impl<Q::template fn, L...>::type;
+
+// mp_drop(_c)<L, N>
+namespace detail
+{
+
+template<class L, class L2> struct mp_drop_impl;
+
+template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>>
+{
+ template<class... W> static mp_identity<L<W...>> f( U*..., mp_identity<W>*... );
+
+ using R = decltype( f( (mp_identity<T>*)0 ... ) );
+
+ using type = typename R::type;
+};
+
+} // namespace detail
+
+template<class L, std::size_t N> using mp_drop_c = typename detail::mp_drop_impl<L, mp_repeat_c<mp_list<void>, N>>::type;
+
+template<class L, class N> using mp_drop = typename detail::mp_drop_impl<L, mp_repeat<mp_list<void>, N>>::type;
+
+// mp_from_sequence<S>
+namespace detail
+{
+
+template<class S> struct mp_from_sequence_impl;
+
+template<template<class T, T... I> class S, class U, U... J> struct mp_from_sequence_impl<S<U, J...>>
+{
+ using type = mp_list<std::integral_constant<U, J>...>;
+};
+
+} // namespace detail
+
+template<class S> using mp_from_sequence = typename detail::mp_from_sequence_impl<S>::type;
+
+// mp_iota(_c)<N>
+template<std::size_t N> using mp_iota_c = mp_from_sequence<make_index_sequence<N>>;
+template<class N> using mp_iota = mp_from_sequence<make_integer_sequence<typename std::remove_const<decltype(N::value)>::type, N::value>>;
+
+// mp_at(_c)<L, I>
+namespace detail
+{
+
+template<class L, std::size_t I> struct mp_at_c_impl;
+
+#if defined(BOOST_MP11_HAS_TYPE_PACK_ELEMENT)
+
+template<template<class...> class L, class... T, std::size_t I> struct mp_at_c_impl<L<T...>, I>
+{
+ using type = __type_pack_element<I, T...>;
+};
+
+#else
+
+template<class L, std::size_t I> struct mp_at_c_impl
+{
+ using _map = mp_transform<mp_list, mp_iota<mp_size<L> >, L>;
+ using type = mp_second<mp_map_find<_map, mp_size_t<I> > >;
+};
+
+#endif
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<class L, std::size_t I> struct mp_at_c_cuda_workaround
+{
+ using type = mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>;
+};
+
+#endif
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<class L, std::size_t I> using mp_at_c = typename detail::mp_at_c_cuda_workaround< L, I >::type::type;
+
+#else
+
+template<class L, std::size_t I> using mp_at_c = typename mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>::type;
+
+#endif
+
+template<class L, class I> using mp_at = mp_at_c<L, std::size_t{ I::value }>;
+
+// mp_take(_c)<L, N>
+namespace detail
+{
+
+template<std::size_t N, class L, class E = void> struct mp_take_c_impl
+{
+};
+
+template<template<class...> class L, class... T>
+struct mp_take_c_impl<0, L<T...>>
+{
+ using type = L<>;
+};
+
+template<template<class...> class L, class T1, class... T>
+struct mp_take_c_impl<1, L<T1, T...>>
+{
+ using type = L<T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class... T>
+struct mp_take_c_impl<2, L<T1, T2, T...>>
+{
+ using type = L<T1, T2>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class... T>
+struct mp_take_c_impl<3, L<T1, T2, T3, T...>>
+{
+ using type = L<T1, T2, T3>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class... T>
+struct mp_take_c_impl<4, L<T1, T2, T3, T4, T...>>
+{
+ using type = L<T1, T2, T3, T4>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class... T>
+struct mp_take_c_impl<5, L<T1, T2, T3, T4, T5, T...>>
+{
+ using type = L<T1, T2, T3, T4, T5>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class... T>
+struct mp_take_c_impl<6, L<T1, T2, T3, T4, T5, T6, T...>>
+{
+ using type = L<T1, T2, T3, T4, T5, T6>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class... T>
+struct mp_take_c_impl<7, L<T1, T2, T3, T4, T5, T6, T7, T...>>
+{
+ using type = L<T1, T2, T3, T4, T5, T6, T7>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class... T>
+struct mp_take_c_impl<8, L<T1, T2, T3, T4, T5, T6, T7, T8, T...>>
+{
+ using type = L<T1, T2, T3, T4, T5, T6, T7, T8>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T>
+struct mp_take_c_impl<9, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>>
+{
+ using type = L<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, std::size_t N>
+struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typename std::enable_if<N >= 10>::type>
+{
+ using type = mp_append<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, typename mp_take_c_impl<N-10, L<T...>>::type>;
+};
+
+} // namespace detail
+
+template<class L, std::size_t N> using mp_take_c = typename detail::mp_take_c_impl<N, L>::type;
+template<class L, class N> using mp_take = typename detail::mp_take_c_impl<std::size_t{ N::value }, L>::type;
+
+// mp_back<L>
+template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
+
+// mp_pop_back<L>
+template<class L> using mp_pop_back = mp_take_c<L, mp_size<L>::value - 1>;
+
+// mp_replace<L, V, W>
+namespace detail
+{
+
+template<class L, class V, class W> struct mp_replace_impl;
+
+template<template<class...> class L, class... T, class V, class W> struct mp_replace_impl<L<T...>, V, W>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+ template<class A> struct _f { using type = mp_if<std::is_same<A, V>, W, A>; };
+ using type = L<typename _f<T>::type...>;
+#else
+ template<class A> using _f = mp_if<std::is_same<A, V>, W, A>;
+ using type = L<_f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, class V, class W> using mp_replace = typename detail::mp_replace_impl<L, V, W>::type;
+
+// mp_replace_if<L, P, W>
+namespace detail
+{
+
+template<class L, template<class...> class P, class W> struct mp_replace_if_impl;
+
+template<template<class...> class L, class... T, template<class...> class P, class W> struct mp_replace_if_impl<L<T...>, P, W>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+ template<class U> struct _f { using type = mp_if<P<U>, W, U>; };
+ using type = L<typename _f<T>::type...>;
+#else
+ template<class U> using _f = mp_if<P<U>, W, U>;
+ using type = L<_f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl<L, P, W>::type;
+template<class L, class Q, class W> using mp_replace_if_q = mp_replace_if<L, Q::template fn, W>;
+
+// mp_copy_if<L, P>
+// in detail/mp_copy_if.hpp
+
+// mp_remove<L, V>
+namespace detail
+{
+
+template<class L, class V> struct mp_remove_impl;
+
+template<template<class...> class L, class... T, class V> struct mp_remove_impl<L<T...>, V>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+ template<class U> struct _f { using type = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>; };
+ using type = mp_append<L<>, typename _f<T>::type...>;
+#else
+ template<class U> using _f = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>;
+ using type = mp_append<L<>, _f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, class V> using mp_remove = typename detail::mp_remove_impl<L, V>::type;
+
+// mp_remove_if<L, P>
+// in detail/mp_remove_if.hpp
+
+// mp_flatten<L, L2 = mp_clear<L>>
+namespace detail
+{
+
+template<class L2> struct mp_flatten_impl
+{
+ template<class T> using fn = mp_if<mp_similar<L2, T>, T, mp_list<T>>;
+};
+
+} // namespace detail
+
+template<class L, class L2 = mp_clear<L>> using mp_flatten = mp_apply<mp_append, mp_push_front<mp_transform_q<detail::mp_flatten_impl<L2>, L>, mp_clear<L>>>;
+
+// mp_partition<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_partition_impl;
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_partition_impl<L<T...>, P>
+{
+ using type = L<mp_copy_if<L<T...>, P>, mp_remove_if<L<T...>, P>>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_partition = typename detail::mp_partition_impl<L, P>::type;
+template<class L, class Q> using mp_partition_q = mp_partition<L, Q::template fn>;
+
+// mp_sort<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_sort_impl;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_sort_impl<L<T...>, P>
+{
+ static_assert( sizeof...(T) == 0, "T... must be empty" );
+ using type = L<>;
+};
+
+#else
+
+template<template<class...> class L, template<class...> class P> struct mp_sort_impl<L<>, P>
+{
+ using type = L<>;
+};
+
+#endif
+
+template<template<class...> class L, class T1, template<class...> class P> struct mp_sort_impl<L<T1>, P>
+{
+ using type = L<T1>;
+};
+
+template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
+{
+ template<class U> using F = P<U, T1>;
+
+ using part = mp_partition<L<T...>, F>;
+
+ using S1 = typename mp_sort_impl<mp_first<part>, P>::type;
+ using S2 = typename mp_sort_impl<mp_second<part>, P>::type;
+
+ using type = mp_append<mp_push_back<S1, T1>, S2>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_sort = typename detail::mp_sort_impl<L, P>::type;
+template<class L, class Q> using mp_sort_q = mp_sort<L, Q::template fn>;
+
+// mp_nth_element(_c)<L, I, P>
+namespace detail
+{
+
+template<class L, std::size_t I, template<class...> class P> struct mp_nth_element_impl;
+
+template<template<class...> class L, class T1, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1>, I, P>
+{
+ static_assert( I == 0, "mp_nth_element index out of range" );
+ using type = T1;
+};
+
+template<template<class...> class L, class T1, class... T, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1, T...>, I, P>
+{
+ static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" );
+
+ template<class U> using F = P<U, T1>;
+
+ using part = mp_partition<L<T...>, F>;
+
+ using L1 = mp_first<part>;
+ static std::size_t const N1 = mp_size<L1>::value;
+
+ using L2 = mp_second<part>;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+ struct detail
+ {
+ struct mp_nth_element_impl_cuda_workaround
+ {
+ using type = mp_cond<
+
+ mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
+ mp_bool<(I == N1)>, mp_identity<T1>,
+ mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>
+
+ >;
+ };
+ };
+
+ using type = typename detail::mp_nth_element_impl_cuda_workaround::type::type;
+
+#else
+
+ using type = typename mp_cond<
+
+ mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
+ mp_bool<(I == N1)>, mp_identity<T1>,
+ mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>
+
+ >::type;
+
+#endif
+};
+
+} // namespace detail
+
+template<class L, std::size_t I, template<class...> class P> using mp_nth_element_c = typename detail::mp_nth_element_impl<L, I, P>::type;
+template<class L, class I, template<class...> class P> using mp_nth_element = typename detail::mp_nth_element_impl<L, std::size_t{ I::value }, P>::type;
+template<class L, class I, class Q> using mp_nth_element_q = mp_nth_element<L, I, Q::template fn>;
+
+// mp_find<L, V>
+namespace detail
+{
+
+template<class L, class V> struct mp_find_impl;
+
+#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
+
+struct mp_index_holder
+{
+ std::size_t i_;
+ bool f_;
+};
+
+constexpr inline mp_index_holder operator+( mp_index_holder const & v, bool f )
+{
+ if( v.f_ )
+ {
+ return v;
+ }
+ else if( f )
+ {
+ return { v.i_, true };
+ }
+ else
+ {
+ return { v.i_ + 1, false };
+ }
+}
+
+template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
+{
+ static constexpr mp_index_holder _v{ 0, false };
+ using type = mp_size_t< (_v + ... + std::is_same<T, V>::value).i_ >;
+};
+
+#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+
+template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
+{
+ using type = mp_size_t<0>;
+};
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+
+constexpr std::size_t cx_find_index( bool const * first, bool const * last )
+{
+ std::size_t m = 0;
+
+ while( first != last && !*first )
+ {
+ ++m;
+ ++first;
+ }
+
+ return m;
+}
+
+#else
+
+constexpr std::size_t cx_find_index( bool const * first, bool const * last )
+{
+ return first == last || *first? 0: 1 + cx_find_index( first + 1, last );
+}
+
+#endif
+
+template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
+{
+ static constexpr bool _v[] = { std::is_same<T, V>::value... };
+ using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >;
+};
+
+#else
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
+{
+ static_assert( sizeof...(T) == 0, "T... must be empty" );
+ using type = mp_size_t<0>;
+};
+
+#else
+
+template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
+{
+ using type = mp_size_t<0>;
+};
+
+#endif
+
+template<template<class...> class L, class... T, class V> struct mp_find_impl<L<V, T...>, V>
+{
+ using type = mp_size_t<0>;
+};
+
+template<template<class...> class L, class T1, class... T, class V> struct mp_find_impl<L<T1, T...>, V>
+{
+ using _r = typename mp_find_impl<mp_list<T...>, V>::type;
+ using type = mp_size_t<1 + _r::value>;
+};
+
+#endif
+
+} // namespace detail
+
+template<class L, class V> using mp_find = typename detail::mp_find_impl<L, V>::type;
+
+// mp_find_if<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_find_if_impl;
+
+#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
+{
+ static constexpr mp_index_holder _v{ 0, false };
+ using type = mp_size_t< (_v + ... + P<T>::value).i_ >;
+};
+
+#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+
+template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
+{
+ using type = mp_size_t<0>;
+};
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
+{
+ static constexpr bool _v[] = { P<T>::value... };
+ using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >;
+};
+
+#else
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
+{
+ static_assert( sizeof...(T) == 0, "T... must be empty" );
+ using type = mp_size_t<0>;
+};
+
+#else
+
+template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
+{
+ using type = mp_size_t<0>;
+};
+
+#endif
+
+template<class L, template<class...> class P> struct mp_find_if_impl_2
+{
+ using _r = typename mp_find_if_impl<L, P>::type;
+ using type = mp_size_t<1 + _r::value>;
+};
+
+template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_find_if_impl<L<T1, T...>, P>
+{
+ using type = typename mp_if<P<T1>, mp_identity<mp_size_t<0>>, mp_find_if_impl_2<mp_list<T...>, P>>::type;
+};
+
+#endif
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_find_if = typename detail::mp_find_if_impl<L, P>::type;
+template<class L, class Q> using mp_find_if_q = mp_find_if<L, Q::template fn>;
+
+// mp_reverse<L>
+namespace detail
+{
+
+template<class L> struct mp_reverse_impl;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T> struct mp_reverse_impl<L<T...>>
+{
+ static_assert( sizeof...(T) == 0, "T... must be empty" );
+ using type = L<>;
+};
+
+#else
+
+template<template<class...> class L> struct mp_reverse_impl<L<>>
+{
+ using type = L<>;
+};
+
+#endif
+
+template<template<class...> class L, class T1> struct mp_reverse_impl<L<T1>>
+{
+ using type = L<T1>;
+};
+
+template<template<class...> class L, class T1, class T2> struct mp_reverse_impl<L<T1, T2>>
+{
+ using type = L<T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3> struct mp_reverse_impl<L<T1, T2, T3>>
+{
+ using type = L<T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4> struct mp_reverse_impl<L<T1, T2, T3, T4>>
+{
+ using type = L<T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5> struct mp_reverse_impl<L<T1, T2, T3, T4, T5>>
+{
+ using type = L<T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6>>
+{
+ using type = L<T6, T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7>>
+{
+ using type = L<T7, T6, T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8>>
+{
+ using type = L<T8, T7, T6, T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9>>
+{
+ using type = L<T9, T8, T7, T6, T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>>
+{
+ using type = mp_push_back<typename mp_reverse_impl<L<T...>>::type, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1>;
+};
+
+} // namespace detail
+
+template<class L> using mp_reverse = typename detail::mp_reverse_impl<L>::type;
+
+// mp_fold<L, V, F>
+// in detail/mp_fold.hpp
+
+// mp_reverse_fold<L, V, F>
+namespace detail
+{
+
+template<class L, class V, template<class...> class F> struct mp_reverse_fold_impl;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T...>, V, F>
+{
+ static_assert( sizeof...(T) == 0, "T... must be empty" );
+ using type = V;
+};
+
+#else
+
+template<template<class...> class L, class V, template<class...> class F> struct mp_reverse_fold_impl<L<>, V, F>
+{
+ using type = V;
+};
+
+#endif
+
+template<template<class...> class L, class T1, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T...>, V, F>
+{
+ using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
+ using type = F<T1, rest>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
+{
+ using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
+ using type = F<T1, F<T2, F<T3, F<T4, F<T5, F<T6, F<T7, F<T8, F<T9, F<T10, rest> > > > > > > > > >;
+};
+
+} // namespace detail
+
+template<class L, class V, template<class...> class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl<L, V, F>::type;
+template<class L, class V, class Q> using mp_reverse_fold_q = mp_reverse_fold<L, V, Q::template fn>;
+
+// mp_unique<L>
+namespace detail
+{
+
+template<class L> struct mp_unique_impl;
+
+template<template<class...> class L, class... T> struct mp_unique_impl<L<T...>>
+{
+ using type = mp_set_push_back<L<>, T...>;
+};
+
+} // namespace detail
+
+template<class L> using mp_unique = typename detail::mp_unique_impl<L>::type;
+
+// mp_unique_if<L, P>
+namespace detail
+{
+
+template<template<class...> class P> struct mp_unique_if_push_back
+{
+ template<class...> struct impl
+ {
+ };
+
+ template<template<class...> class L, class... Ts, class T>
+ struct impl<L<Ts...>, T>
+ {
+ using type = mp_if<mp_any<P<Ts, T>...>, L<Ts...>, L<Ts..., T>>;
+ };
+
+ template<class... T> using fn = typename impl<T...>::type;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P>
+using mp_unique_if = mp_fold_q<L, mp_clear<L>, detail::mp_unique_if_push_back<P>>;
+
+template<class L, class Q> using mp_unique_if_q = mp_unique_if<L, Q::template fn>;
+
+// mp_all_of<L, P>
+template<class L, template<class...> class P> using mp_all_of = mp_bool< mp_count_if<L, P>::value == mp_size<L>::value >;
+template<class L, class Q> using mp_all_of_q = mp_all_of<L, Q::template fn>;
+
+// mp_none_of<L, P>
+template<class L, template<class...> class P> using mp_none_of = mp_bool< mp_count_if<L, P>::value == 0 >;
+template<class L, class Q> using mp_none_of_q = mp_none_of<L, Q::template fn>;
+
+// mp_any_of<L, P>
+template<class L, template<class...> class P> using mp_any_of = mp_bool< mp_count_if<L, P>::value != 0 >;
+template<class L, class Q> using mp_any_of_q = mp_any_of<L, Q::template fn>;
+
+// mp_replace_at_c<L, I, W>
+namespace detail
+{
+
+template<class L, class I, class W> struct mp_replace_at_impl
+{
+ static_assert( I::value >= 0, "mp_replace_at<L, I, W>: I must not be negative" );
+
+ template<class T1, class T2> using _p = std::is_same<T2, mp_size_t<I::value>>;
+ template<class T1, class T2> using _f = W;
+
+ using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L> > >;
+};
+
+} // namespace detail
+
+template<class L, class I, class W> using mp_replace_at = typename detail::mp_replace_at_impl<L, I, W>::type;
+template<class L, std::size_t I, class W> using mp_replace_at_c = typename detail::mp_replace_at_impl<L, mp_size_t<I>, W>::type;
+
+//mp_for_each<L>(f)
+namespace detail
+{
+
+template<class... T, class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<T...>, F && f )
+{
+ using A = int[sizeof...(T)];
+ return (void)A{ ((void)f(T()), 0)... }, std::forward<F>(f);
+}
+
+template<class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f )
+{
+ return std::forward<F>(f);
+}
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, >= 1900 )
+
+// msvc has a limit of 1024
+
+template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value <= 1024, F> mp_for_each( F && f )
+{
+ return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
+}
+
+template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value >= 1025, F> mp_for_each( F && f )
+{
+ using L2 = mp_rename<L, mp_list>;
+
+ using L3 = mp_take_c<L2, 1024>;
+ using L4 = mp_drop_c<L2, 1024>;
+
+ return mp_for_each<L4>( mp_for_each<L3>( std::forward<F>(f) ) );
+}
+
+#else
+
+template<class L, class F> BOOST_MP11_CONSTEXPR F mp_for_each( F && f )
+{
+ return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
+}
+
+#endif
+
+// mp_insert<L, I, T...>
+template<class L, class I, class... T> using mp_insert = mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;
+
+// mp_insert_c<L, I, T...>
+template<class L, std::size_t I, class... T> using mp_insert_c = mp_append<mp_take_c<L, I>, mp_push_front<mp_drop_c<L, I>, T...>>;
+
+// mp_erase<L, I, J>
+template<class L, class I, class J> using mp_erase = mp_append<mp_take<L, I>, mp_drop<L, J>>;
+
+// mp_erase_c<L, I, J>
+template<class L, std::size_t I, std::size_t J> using mp_erase_c = mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;
+
+// mp_starts_with<L1, L2>
+// contributed by Glen Joseph Fernandes (glenjofe@gmail.com)
+namespace detail {
+
+template<class L1, class L2>
+struct mp_starts_with_impl { };
+
+template<template<class...> class L1, class... T1, template<class...> class L2,
+ class... T2>
+struct mp_starts_with_impl<L1<T1...>, L2<T2...> > {
+ template<class L>
+ static mp_false check(L);
+
+ template<class... T>
+ static mp_true check(mp_list<T2..., T...>);
+
+ using type = decltype(check(mp_list<T1...>()));
+};
+
+} // namespace detail
+
+template<class L1, class L2>
+using mp_starts_with = typename detail::mp_starts_with_impl<L1, L2>::type;
+
+// mp_rotate_left(_c)<L, N>
+namespace detail
+{
+
+// limit divisor to 1 to avoid division by 0 and give a rotation of 0 for lists containing 0 or 1 elements
+template<std::size_t Ln, std::size_t N> using canonical_left_rotation = mp_size_t<N % (Ln == 0? 1: Ln)>;
+
+// perform right rotation as a left rotation by inverting the number of elements to rotate
+template<std::size_t Ln, std::size_t N> using canonical_right_rotation = mp_size_t<Ln - N % (Ln == 0? 1: Ln)>;
+
+// avoid errors when rotating fixed-sized lists by using mp_list for the transformation
+template<class L, class N, class L2 = mp_rename<L, mp_list>> using mp_rotate_impl = mp_assign<L, mp_append< mp_drop<L2, N>, mp_take<L2, N> >>;
+
+} // namespace detail
+
+template<class L, std::size_t N> using mp_rotate_left_c = detail::mp_rotate_impl<L, detail::canonical_left_rotation<mp_size<L>::value, N>>;
+template<class L, class N> using mp_rotate_left = mp_rotate_left_c<L, std::size_t{ N::value }>;
+
+// mp_rotate_right(_c)<L, N>
+template<class L, std::size_t N> using mp_rotate_right_c = mp_rotate_left<L, detail::canonical_right_rotation<mp_size<L>::value, N>>;
+template<class L, class N> using mp_rotate_right = mp_rotate_right_c<L, std::size_t{ N::value }>;
+
+// mp_min_element<L, P>
+// mp_max_element<L, P>
+// in detail/mp_min_element.hpp
+
+// mp_power_set<L>
+namespace detail
+{
+
+template<class L> struct mp_power_set_impl;
+
+} // namespace detail
+
+template<class L> using mp_power_set = typename detail::mp_power_set_impl<L>::type;
+
+namespace detail
+{
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T> struct mp_power_set_impl< L<T...> >
+{
+ static_assert( sizeof...(T) == 0, "T... must be empty" );
+ using type = L< L<> >;
+};
+
+#else
+
+template<template<class...> class L> struct mp_power_set_impl< L<> >
+{
+ using type = L< L<> >;
+};
+
+#endif
+
+template<template<class...> class L, class T1, class... T> struct mp_power_set_impl< L<T1, T...> >
+{
+ using S1 = mp_power_set< L<T...> >;
+
+ template<class L2> using _f = mp_push_front<L2, T1>;
+
+ using S2 = mp_transform<_f, S1>;
+
+ using type = mp_append< S1, S2 >;
+};
+
+} // namespace detail
+
+// mp_partial_sum<L, V, F>
+namespace detail
+{
+
+template<template<class...> class F> struct mp_partial_sum_impl_f
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
+
+ template<class V, class T> using fn = mp_list<F<mp_first<V>, T>, mp_push_back<mp_second<V>, F<mp_first<V>, T>> >;
+
+#else
+
+ template<class V, class T, class N = F<mp_first<V>, T>> using fn = mp_list<N, mp_push_back<mp_second<V>, N>>;
+
+#endif
+};
+
+} // namespace detail
+
+template<class L, class V, template<class...> class F> using mp_partial_sum = mp_second<mp_fold_q<L, mp_list<V, mp_clear<L>>, detail::mp_partial_sum_impl_f<F>> >;
+template<class L, class V, class Q> using mp_partial_sum_q = mp_partial_sum<L, V, Q::template fn>;
+
+// mp_iterate<V, F, R>
+namespace detail
+{
+
+template<class V, template<class...> class F, template<class...> class R, class N> struct mp_iterate_impl;
+
+} // namespace detail
+
+template<class V, template<class...> class F, template<class...> class R> using mp_iterate = typename detail::mp_iterate_impl<V, F, R, mp_valid<R, V>>::type;
+
+namespace detail
+{
+
+template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_false>
+{
+ template<class X> using _f = mp_list<F<X>>;
+ using type = mp_eval_or<mp_list<>, _f, V>;
+};
+
+template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_true>
+{
+ using type = mp_push_front<mp_iterate<R<V>, F, R>, F<V>>;
+};
+
+} // namespace detail
+
+template<class V, class Qf, class Qr> using mp_iterate_q = mp_iterate<V, Qf::template fn, Qr::template fn>;
+
+// mp_pairwise_fold<L, F>
+namespace detail
+{
+
+template<class L, class Q> using mp_pairwise_fold_impl = mp_transform_q<Q, mp_pop_back<L>, mp_pop_front<L>>;
+
+} // namespace detail
+
+template<class L, class Q> using mp_pairwise_fold_q = mp_eval_if<mp_empty<L>, mp_clear<L>, detail::mp_pairwise_fold_impl, L, Q>;
+template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwise_fold_q<L, mp_quote<F>>;
+
+// mp_intersperse<L, S>
+namespace detail
+{
+
+template<class L, class S> struct mp_intersperse_impl
+{
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, class S> struct mp_intersperse_impl<L<T...>, S>
+{
+ static_assert( sizeof...(T) == 0, "T... must be empty" );
+ using type = L<>;
+};
+
+#else
+
+template<template<class...> class L, class S> struct mp_intersperse_impl<L<>, S>
+{
+ using type = L<>;
+};
+
+#endif
+
+template<template<class...> class L, class T1, class... T, class S> struct mp_intersperse_impl<L<T1, T...>, S>
+{
+ using type = mp_append<L<T1>, L<S, T>...>;
+};
+
+} // namespace detail
+
+template<class L, class S> using mp_intersperse = typename detail::mp_intersperse_impl<L, S>::type;
+
+// mp_split<L, S>
+namespace detail
+{
+
+template<class L, class S, class J> struct mp_split_impl;
+
+} // namespace detail
+
+template<class L, class S> using mp_split = typename detail::mp_split_impl<L, S, mp_find<L, S>>::type;
+
+namespace detail
+{
+
+template<class L, class S, class J> using mp_split_impl_ = mp_push_front<mp_split<mp_drop_c<L, J::value + 1>, S>, mp_take<L, J>>;
+
+template<class L, class S, class J> struct mp_split_impl
+{
+ using type = mp_eval_if_c<mp_size<L>::value == J::value, mp_push_back<mp_clear<L>, L>, mp_split_impl_, L, S, J>;
+};
+
+} // namespace detail
+
+// mp_join<L, S>
+
+template<class L, class S> using mp_join = mp_apply<mp_append, mp_intersperse<L, mp_list<S>>>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_BIND_HPP_INCLUDED
+#define BOOST_MP11_BIND_HPP_INCLUDED
+
+// Copyright 2017, 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
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/utility.hpp>
+#include <cstddef>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_bind_front
+template<template<class...> class F, class... T> struct mp_bind_front
+{
+ // the indirection through mp_defer works around the language inability
+ // to expand U... into a fixed parameter list of an alias template
+
+ template<class... U> using fn = typename mp_defer<F, T..., U...>::type;
+};
+
+template<class Q, class... T> using mp_bind_front_q = mp_bind_front<Q::template fn, T...>;
+
+// mp_bind_back
+template<template<class...> class F, class... T> struct mp_bind_back
+{
+ template<class... U> using fn = typename mp_defer<F, U..., T...>::type;
+};
+
+template<class Q, class... T> using mp_bind_back_q = mp_bind_back<Q::template fn, T...>;
+
+// mp_arg
+template<std::size_t I> struct mp_arg
+{
+ template<class... T> using fn = mp_at_c<mp_list<T...>, I>;
+};
+
+using _1 = mp_arg<0>;
+using _2 = mp_arg<1>;
+using _3 = mp_arg<2>;
+using _4 = mp_arg<3>;
+using _5 = mp_arg<4>;
+using _6 = mp_arg<5>;
+using _7 = mp_arg<6>;
+using _8 = mp_arg<7>;
+using _9 = mp_arg<8>;
+
+// mp_bind
+template<template<class...> class F, class... T> struct mp_bind;
+
+namespace detail
+{
+
+template<class V, class... T> struct eval_bound_arg
+{
+ using type = V;
+};
+
+template<std::size_t I, class... T> struct eval_bound_arg<mp_arg<I>, T...>
+{
+ using type = typename mp_arg<I>::template fn<T...>;
+};
+
+template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind<F, U...>, T...>
+{
+ using type = typename mp_bind<F, U...>::template fn<T...>;
+};
+
+template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind_front<F, U...>, T...>
+{
+ using type = typename mp_bind_front<F, U...>::template fn<T...>;
+};
+
+template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind_back<F, U...>, T...>
+{
+ using type = typename mp_bind_back<F, U...>::template fn<T...>;
+};
+
+} // namespace detail
+
+template<template<class...> class F, class... T> struct mp_bind
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1915 )
+private:
+
+ template<class... U> struct _f { using type = F<typename detail::eval_bound_arg<T, U...>::type...>; };
+
+public:
+
+ template<class... U> using fn = typename _f<U...>::type;
+
+#else
+
+ template<class... U> using fn = F<typename detail::eval_bound_arg<T, U...>::type...>;
+
+#endif
+};
+
+template<class Q, class... T> using mp_bind_q = mp_bind<Q::template fn, T...>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_BIND_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_CONFIG_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_CONFIG_HPP_INCLUDED
+
+// Copyright 2016, 2018, 2019 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
+
+// BOOST_MP11_WORKAROUND
+
+#if defined( BOOST_STRICT_CONFIG ) || defined( BOOST_MP11_NO_WORKAROUNDS )
+
+# define BOOST_MP11_WORKAROUND( symbol, test ) 0
+
+#else
+
+# define BOOST_MP11_WORKAROUND( symbol, test ) ((symbol) != 0 && ((symbol) test))
+
+#endif
+
+//
+
+#define BOOST_MP11_CUDA 0
+#define BOOST_MP11_CLANG 0
+#define BOOST_MP11_INTEL 0
+#define BOOST_MP11_GCC 0
+#define BOOST_MP11_MSVC 0
+
+#define BOOST_MP11_CONSTEXPR constexpr
+
+#if defined( __CUDACC__ )
+
+// nvcc
+
+# undef BOOST_MP11_CUDA
+# define BOOST_MP11_CUDA (__CUDACC_VER_MAJOR__ * 1000000 + __CUDACC_VER_MINOR__ * 10000 + __CUDACC_VER_BUILD__)
+
+// CUDA (8.0) has no constexpr support in msvc mode:
+# if defined(_MSC_VER) && (BOOST_MP11_CUDA < 9000000)
+
+# define BOOST_MP11_NO_CONSTEXPR
+
+# undef BOOST_MP11_CONSTEXPR
+# define BOOST_MP11_CONSTEXPR
+
+# endif
+
+#endif
+
+#if defined(__clang__)
+
+// Clang
+
+# undef BOOST_MP11_CLANG
+# define BOOST_MP11_CLANG (__clang_major__ * 100 + __clang_minor__)
+
+# if defined(__has_cpp_attribute)
+# if __has_cpp_attribute(fallthrough) && __cplusplus >= 201406L // Clang 3.9+ in c++1z mode
+# define BOOST_MP11_HAS_FOLD_EXPRESSIONS
+# endif
+# endif
+
+#if BOOST_MP11_CLANG < 400 && __cplusplus >= 201402L \
+ && defined( __GLIBCXX__ ) && !__has_include(<shared_mutex>)
+
+// Clang pre-4 in C++14 mode, libstdc++ pre-4.9, ::gets is not defined,
+// but Clang tries to import it into std
+
+ extern "C" char *gets (char *__s);
+#endif
+
+#elif defined(__INTEL_COMPILER)
+
+// Intel C++
+
+# undef BOOST_MP11_INTEL
+# define BOOST_MP11_INTEL __INTEL_COMPILER
+
+#elif defined(__GNUC__)
+
+// g++
+
+# undef BOOST_MP11_GCC
+# define BOOST_MP11_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+
+#elif defined(_MSC_VER)
+
+// MS Visual C++
+
+# undef BOOST_MP11_MSVC
+# define BOOST_MP11_MSVC _MSC_VER
+
+# if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+# define BOOST_MP11_NO_CONSTEXPR
+# endif
+
+#if _MSC_FULL_VER < 190024210 // 2015u3
+# undef BOOST_MP11_CONSTEXPR
+# define BOOST_MP11_CONSTEXPR
+#endif
+
+#endif
+
+// BOOST_MP11_HAS_CXX14_CONSTEXPR
+
+#if !defined(BOOST_MP11_NO_CONSTEXPR) && defined(__cpp_constexpr) && __cpp_constexpr >= 201304
+# define BOOST_MP11_HAS_CXX14_CONSTEXPR
+#endif
+
+// BOOST_MP11_HAS_FOLD_EXPRESSIONS
+
+#if !defined(BOOST_MP11_HAS_FOLD_EXPRESSIONS) && defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603
+# define BOOST_MP11_HAS_FOLD_EXPRESSIONS
+#endif
+
+// BOOST_MP11_HAS_TYPE_PACK_ELEMENT
+
+#if defined(__has_builtin)
+# if __has_builtin(__type_pack_element)
+# define BOOST_MP11_HAS_TYPE_PACK_ELEMENT
+# endif
+#endif
+
+// BOOST_MP11_DEPRECATED(msg)
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CLANG, < 304 )
+# define BOOST_MP11_DEPRECATED(msg)
+#elif defined(__GNUC__) || defined(__clang__)
+# define BOOST_MP11_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#elif defined(_MSC_VER) && _MSC_VER >= 1900
+# define BOOST_MP11_DEPRECATED(msg) [[deprecated(msg)]]
+#else
+# define BOOST_MP11_DEPRECATED(msg)
+#endif
+
+#endif // #ifndef BOOST_MP11_DETAIL_CONFIG_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_APPEND_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_APPEND_HPP_INCLUDED
+
+// Copyright 2015-2017 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
+
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_append<L...>
+
+namespace detail
+{
+
+template<class... L> struct mp_append_impl;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<class... L> struct mp_append_impl
+{
+};
+
+template<> struct mp_append_impl<>
+{
+ using type = mp_list<>;
+};
+
+template<template<class...> class L, class... T> struct mp_append_impl<L<T...>>
+{
+ using type = L<T...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_append_impl<L1<T1...>, L2<T2...>>
+{
+ using type = L1<T1..., T2...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_append_impl<L1<T1...>, L2<T2...>, L3<T3...>>
+{
+ using type = L1<T1..., T2..., T3...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4> struct mp_append_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>>
+{
+ using type = L1<T1..., T2..., T3..., T4...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, template<class...> class L5, class... T5, class... Lr> struct mp_append_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L5<T5...>, Lr...>
+{
+ using type = typename mp_append_impl<L1<T1..., T2..., T3..., T4..., T5...>, Lr...>::type;
+};
+
+#else
+
+template<class L1 = mp_list<>, class L2 = mp_list<>, class L3 = mp_list<>, class L4 = mp_list<>, class L5 = mp_list<>, class L6 = mp_list<>, class L7 = mp_list<>, class L8 = mp_list<>, class L9 = mp_list<>, class L10 = mp_list<>, class L11 = mp_list<>> struct append_11_impl
+{
+};
+
+template<
+ template<class...> class L1, class... T1,
+ template<class...> class L2, class... T2,
+ template<class...> class L3, class... T3,
+ template<class...> class L4, class... T4,
+ template<class...> class L5, class... T5,
+ template<class...> class L6, class... T6,
+ template<class...> class L7, class... T7,
+ template<class...> class L8, class... T8,
+ template<class...> class L9, class... T9,
+ template<class...> class L10, class... T10,
+ template<class...> class L11, class... T11>
+
+struct append_11_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L5<T5...>, L6<T6...>, L7<T7...>, L8<T8...>, L9<T9...>, L10<T10...>, L11<T11...>>
+{
+ using type = L1<T1..., T2..., T3..., T4..., T5..., T6..., T7..., T8..., T9..., T10..., T11...>;
+};
+
+template<
+
+ class L00 = mp_list<>, class L01 = mp_list<>, class L02 = mp_list<>, class L03 = mp_list<>, class L04 = mp_list<>, class L05 = mp_list<>, class L06 = mp_list<>, class L07 = mp_list<>, class L08 = mp_list<>, class L09 = mp_list<>, class L0A = mp_list<>,
+ class L10 = mp_list<>, class L11 = mp_list<>, class L12 = mp_list<>, class L13 = mp_list<>, class L14 = mp_list<>, class L15 = mp_list<>, class L16 = mp_list<>, class L17 = mp_list<>, class L18 = mp_list<>, class L19 = mp_list<>,
+ class L20 = mp_list<>, class L21 = mp_list<>, class L22 = mp_list<>, class L23 = mp_list<>, class L24 = mp_list<>, class L25 = mp_list<>, class L26 = mp_list<>, class L27 = mp_list<>, class L28 = mp_list<>, class L29 = mp_list<>,
+ class L30 = mp_list<>, class L31 = mp_list<>, class L32 = mp_list<>, class L33 = mp_list<>, class L34 = mp_list<>, class L35 = mp_list<>, class L36 = mp_list<>, class L37 = mp_list<>, class L38 = mp_list<>, class L39 = mp_list<>,
+ class L40 = mp_list<>, class L41 = mp_list<>, class L42 = mp_list<>, class L43 = mp_list<>, class L44 = mp_list<>, class L45 = mp_list<>, class L46 = mp_list<>, class L47 = mp_list<>, class L48 = mp_list<>, class L49 = mp_list<>,
+ class L50 = mp_list<>, class L51 = mp_list<>, class L52 = mp_list<>, class L53 = mp_list<>, class L54 = mp_list<>, class L55 = mp_list<>, class L56 = mp_list<>, class L57 = mp_list<>, class L58 = mp_list<>, class L59 = mp_list<>,
+ class L60 = mp_list<>, class L61 = mp_list<>, class L62 = mp_list<>, class L63 = mp_list<>, class L64 = mp_list<>, class L65 = mp_list<>, class L66 = mp_list<>, class L67 = mp_list<>, class L68 = mp_list<>, class L69 = mp_list<>,
+ class L70 = mp_list<>, class L71 = mp_list<>, class L72 = mp_list<>, class L73 = mp_list<>, class L74 = mp_list<>, class L75 = mp_list<>, class L76 = mp_list<>, class L77 = mp_list<>, class L78 = mp_list<>, class L79 = mp_list<>,
+ class L80 = mp_list<>, class L81 = mp_list<>, class L82 = mp_list<>, class L83 = mp_list<>, class L84 = mp_list<>, class L85 = mp_list<>, class L86 = mp_list<>, class L87 = mp_list<>, class L88 = mp_list<>, class L89 = mp_list<>,
+ class L90 = mp_list<>, class L91 = mp_list<>, class L92 = mp_list<>, class L93 = mp_list<>, class L94 = mp_list<>, class L95 = mp_list<>, class L96 = mp_list<>, class L97 = mp_list<>, class L98 = mp_list<>, class L99 = mp_list<>,
+ class LA0 = mp_list<>, class LA1 = mp_list<>, class LA2 = mp_list<>, class LA3 = mp_list<>, class LA4 = mp_list<>, class LA5 = mp_list<>, class LA6 = mp_list<>, class LA7 = mp_list<>, class LA8 = mp_list<>, class LA9 = mp_list<>
+
+> struct append_111_impl
+{
+ using type = typename append_11_impl<
+
+ typename append_11_impl<L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A>::type,
+ typename append_11_impl<mp_list<>, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19>::type,
+ typename append_11_impl<mp_list<>, L20, L21, L22, L23, L24, L25, L26, L27, L28, L29>::type,
+ typename append_11_impl<mp_list<>, L30, L31, L32, L33, L34, L35, L36, L37, L38, L39>::type,
+ typename append_11_impl<mp_list<>, L40, L41, L42, L43, L44, L45, L46, L47, L48, L49>::type,
+ typename append_11_impl<mp_list<>, L50, L51, L52, L53, L54, L55, L56, L57, L58, L59>::type,
+ typename append_11_impl<mp_list<>, L60, L61, L62, L63, L64, L65, L66, L67, L68, L69>::type,
+ typename append_11_impl<mp_list<>, L70, L71, L72, L73, L74, L75, L76, L77, L78, L79>::type,
+ typename append_11_impl<mp_list<>, L80, L81, L82, L83, L84, L85, L86, L87, L88, L89>::type,
+ typename append_11_impl<mp_list<>, L90, L91, L92, L93, L94, L95, L96, L97, L98, L99>::type,
+ typename append_11_impl<mp_list<>, LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9>::type
+
+ >::type;
+};
+
+template<
+
+ class L00, class L01, class L02, class L03, class L04, class L05, class L06, class L07, class L08, class L09, class L0A,
+ class L10, class L11, class L12, class L13, class L14, class L15, class L16, class L17, class L18, class L19,
+ class L20, class L21, class L22, class L23, class L24, class L25, class L26, class L27, class L28, class L29,
+ class L30, class L31, class L32, class L33, class L34, class L35, class L36, class L37, class L38, class L39,
+ class L40, class L41, class L42, class L43, class L44, class L45, class L46, class L47, class L48, class L49,
+ class L50, class L51, class L52, class L53, class L54, class L55, class L56, class L57, class L58, class L59,
+ class L60, class L61, class L62, class L63, class L64, class L65, class L66, class L67, class L68, class L69,
+ class L70, class L71, class L72, class L73, class L74, class L75, class L76, class L77, class L78, class L79,
+ class L80, class L81, class L82, class L83, class L84, class L85, class L86, class L87, class L88, class L89,
+ class L90, class L91, class L92, class L93, class L94, class L95, class L96, class L97, class L98, class L99,
+ class LA0, class LA1, class LA2, class LA3, class LA4, class LA5, class LA6, class LA7, class LA8, class LA9,
+ class... Lr
+
+> struct append_inf_impl
+{
+ using prefix = typename append_111_impl<
+
+ L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A,
+ L10, L11, L12, L13, L14, L15, L16, L17, L18, L19,
+ L20, L21, L22, L23, L24, L25, L26, L27, L28, L29,
+ L30, L31, L32, L33, L34, L35, L36, L37, L38, L39,
+ L40, L41, L42, L43, L44, L45, L46, L47, L48, L49,
+ L50, L51, L52, L53, L54, L55, L56, L57, L58, L59,
+ L60, L61, L62, L63, L64, L65, L66, L67, L68, L69,
+ L70, L71, L72, L73, L74, L75, L76, L77, L78, L79,
+ L80, L81, L82, L83, L84, L85, L86, L87, L88, L89,
+ L90, L91, L92, L93, L94, L95, L96, L97, L98, L99,
+ LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9
+
+ >::type;
+
+ using type = typename mp_append_impl<prefix, Lr...>::type;
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<class... L>
+struct mp_append_impl_cuda_workaround
+{
+ using type = mp_if_c<(sizeof...(L) > 111), mp_quote<append_inf_impl>, mp_if_c<(sizeof...(L) > 11), mp_quote<append_111_impl>, mp_quote<append_11_impl> > >;
+};
+
+template<class... L> struct mp_append_impl: mp_append_impl_cuda_workaround<L...>::type::template fn<L...>
+{
+};
+
+#else
+
+template<class... L> struct mp_append_impl: mp_if_c<(sizeof...(L) > 111), mp_quote<append_inf_impl>, mp_if_c<(sizeof...(L) > 11), mp_quote<append_111_impl>, mp_quote<append_11_impl> > >::template fn<L...>
+{
+};
+
+#endif
+
+#endif
+
+} // namespace detail
+
+template<class... L> using mp_append = typename detail::mp_append_impl<L...>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_APPEND_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_COPY_IF_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_COPY_IF_HPP_INCLUDED
+
+// Copyright 2015-2019 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
+
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_copy_if<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_copy_if_impl
+{
+};
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_copy_if_impl<L<T...>, P>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+ template<class U> struct _f { using type = mp_if<P<U>, mp_list<U>, mp_list<>>; };
+ using type = mp_append<L<>, typename _f<T>::type...>;
+#else
+ template<class U> using _f = mp_if<P<U>, mp_list<U>, mp_list<>>;
+ using type = mp_append<L<>, _f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_copy_if = typename detail::mp_copy_if_impl<L, P>::type;
+template<class L, class Q> using mp_copy_if_q = mp_copy_if<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_COPY_IF_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_COUNT_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_COUNT_HPP_INCLUDED
+
+// Copyright 2015, 2016 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
+
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/detail/mp_plus.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_count<L, V>
+namespace detail
+{
+
+#if !defined( BOOST_MP11_NO_CONSTEXPR )
+
+constexpr std::size_t cx_plus()
+{
+ return 0;
+}
+
+template<class T1, class... T> constexpr std::size_t cx_plus(T1 t1, T... t)
+{
+ return static_cast<std::size_t>(t1) + cx_plus(t...);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T>
+constexpr std::size_t cx_plus(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T... t)
+{
+ return static_cast<std::size_t>(t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8 + t9 + t10) + cx_plus(t...);
+}
+
+#endif
+
+template<class L, class V> struct mp_count_impl;
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+
+template<class V, class... T> constexpr std::size_t cx_count()
+{
+ constexpr bool a[] = { false, std::is_same<T, V>::value... };
+
+ std::size_t r = 0;
+
+ for( std::size_t i = 1; i < sizeof...(T) + 1; ++i )
+ {
+ r += a[ i ];
+ }
+
+ return r;
+}
+
+template<template<class...> class L, class... T, class V> struct mp_count_impl<L<T...>, V>
+{
+ using type = mp_size_t<cx_count<V, T...>()>;
+};
+
+#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+
+template<template<class...> class L, class... T, class V> struct mp_count_impl<L<T...>, V>
+{
+ using type = mp_size_t<cx_plus(std::is_same<T, V>::value...)>;
+};
+
+#else
+
+template<template<class...> class L, class... T, class V> struct mp_count_impl<L<T...>, V>
+{
+ using type = mp_size_t<mp_plus<std::is_same<T, V>...>::value>;
+};
+
+#endif
+
+} // namespace detail
+
+template<class L, class V> using mp_count = typename detail::mp_count_impl<L, V>::type;
+
+// mp_count_if<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_count_if_impl;
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
+
+template<template<class...> class P, class... T> constexpr std::size_t cx_count_if()
+{
+ constexpr bool a[] = { false, static_cast<bool>( P<T>::value )... };
+
+ std::size_t r = 0;
+
+ for( std::size_t i = 1; i < sizeof...(T) + 1; ++i )
+ {
+ r += a[ i ];
+ }
+
+ return r;
+}
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_count_if_impl<L<T...>, P>
+{
+ using type = mp_size_t<cx_count_if<P, T...>()>;
+};
+
+#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_count_if_impl<L<T...>, P>
+{
+ using type = mp_size_t<cx_plus(mp_to_bool<P<T>>::value...)>;
+};
+
+#else
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_count_if_impl<L<T...>, P>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+ template<class T> struct _f { using type = mp_to_bool<P<T>>; };
+ using type = mp_size_t<mp_plus<typename _f<T>::type...>::value>;
+
+#else
+
+ using type = mp_size_t<mp_plus<mp_to_bool<P<T>>...>::value>;
+
+#endif
+};
+
+#endif
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_count_if = typename detail::mp_count_if_impl<L, P>::type;
+template<class L, class Q> using mp_count_if_q = mp_count_if<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_COUNT_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_FOLD_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_FOLD_HPP_INCLUDED
+
+// Copyright 2015-2017 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
+
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_fold<L, V, F>
+namespace detail
+{
+
+template<class L, class V, template<class...> class F> struct mp_fold_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_fold is not a list
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, class V, template<class...> class F> struct mp_fold_impl<L<T...>, V, F>
+{
+ static_assert( sizeof...(T) == 0, "T... must be empty" );
+ using type = V;
+};
+
+#else
+
+template<template<class...> class L, class V, template<class...> class F> struct mp_fold_impl<L<>, V, F>
+{
+ using type = V;
+};
+
+#endif
+
+template<template<class...> class L, class T1, class... T, class V, template<class...> class F> struct mp_fold_impl<L<T1, T...>, V, F>
+{
+ using type = typename mp_fold_impl<L<T...>, F<V, T1>, F>::type;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
+{
+ using type = typename mp_fold_impl<L<T...>, F<F<F<F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>, T10>, F>::type;
+};
+
+} // namespace detail
+
+template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<L, V, F>::type;
+template<class L, class V, class Q> using mp_fold_q = mp_fold<L, V, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_FOLD_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED
+
+// Copyright 2015-2021 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
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_front<L>
+namespace detail
+{
+
+template<class L> struct mp_front_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_front
+// is either not a list, or is an empty list
+};
+
+template<template<class...> class L, class T1, class... T> struct mp_front_impl<L<T1, T...>>
+{
+ using type = T1;
+};
+
+} // namespace detail
+
+template<class L> using mp_front = typename detail::mp_front_impl<L>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_IS_LIST_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_IS_LIST_HPP_INCLUDED
+
+// Copyright 2015-2019 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
+
+#include <boost/mp11/integral.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_is_list<L>
+namespace detail
+{
+
+template<class L> struct mp_is_list_impl
+{
+ using type = mp_false;
+};
+
+template<template<class...> class L, class... T> struct mp_is_list_impl<L<T...>>
+{
+ using type = mp_true;
+};
+
+} // namespace detail
+
+template<class L> using mp_is_list = typename detail::mp_is_list_impl<L>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_IS_LIST_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_LIST_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_LIST_HPP_INCLUDED
+
+// Copyright 2015, 2016 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
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_list<T...>
+template<class... T> struct mp_list
+{
+};
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_LIST_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_MAP_FIND_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_MAP_FIND_HPP_INCLUDED
+
+// Copyright 2015 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
+
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
+
+// not exactly good practice, but...
+namespace std
+{
+ template<class... _Types> class tuple;
+}
+
+#endif
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_map_find
+namespace detail
+{
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
+
+template<class T> using mpmf_wrap = mp_identity<T>;
+template<class T> using mpmf_unwrap = typename T::type;
+
+#else
+
+template<class... T> struct mpmf_tuple {};
+
+template<class T> struct mpmf_wrap_impl
+{
+ using type = mp_identity<T>;
+};
+
+template<class... T> struct mpmf_wrap_impl< std::tuple<T...> >
+{
+ using type = mp_identity< mpmf_tuple<T...> >;
+};
+
+template<class T> using mpmf_wrap = typename mpmf_wrap_impl<T>::type;
+
+template<class T> struct mpmf_unwrap_impl
+{
+ using type = typename T::type;
+};
+
+template<class... T> struct mpmf_unwrap_impl< mp_identity< mpmf_tuple<T...> > >
+{
+ using type = std::tuple<T...>;
+};
+
+template<class T> using mpmf_unwrap = typename mpmf_unwrap_impl<T>::type;
+
+#endif // #if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
+
+template<class M, class K> struct mp_map_find_impl;
+
+template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
+{
+ using U = mp_inherit<mpmf_wrap<T>...>;
+
+ template<template<class...> class L, class... U> static mp_identity<L<K, U...>> f( mp_identity<L<K, U...>>* );
+ static mp_identity<void> f( ... );
+
+ using type = mpmf_unwrap< decltype( f((U*)0) ) >;
+};
+
+} // namespace detail
+
+template<class M, class K> using mp_map_find = typename detail::mp_map_find_impl<M, K>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_MAP_FIND_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_MIN_ELEMENT_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_MIN_ELEMENT_HPP_INCLUDED
+
+// Copyright 2015-2017 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
+
+#include <boost/mp11/detail/mp_fold.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_min_element<L, P>
+namespace detail
+{
+
+template<template<class...> class P> struct select_min
+{
+ template<class T1, class T2> using fn = mp_if<P<T1, T2>, T1, T2>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_min_element = mp_fold_q<mp_rest<L>, mp_first<L>, detail::select_min<P>>;
+template<class L, class Q> using mp_min_element_q = mp_min_element<L, Q::template fn>;
+
+// mp_max_element<L, P>
+namespace detail
+{
+
+template<template<class...> class P> struct select_max
+{
+ template<class T1, class T2> using fn = mp_if<P<T2, T1>, T1, T2>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_max_element = mp_fold_q<mp_rest<L>, mp_first<L>, detail::select_max<P>>;
+template<class L, class Q> using mp_max_element_q = mp_max_element<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_MIN_ELEMENT_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_PLUS_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_PLUS_HPP_INCLUDED
+
+// Copyright 2015 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
+
+#include <boost/mp11/detail/config.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_plus
+namespace detail
+{
+
+#if defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+template<class... T> struct mp_plus_impl
+{
+ static const auto _v = (T::value + ... + 0);
+ using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+#else
+
+template<class... T> struct mp_plus_impl;
+
+template<> struct mp_plus_impl<>
+{
+ using type = std::integral_constant<int, 0>;
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+
+template<class T1, class... T> struct mp_plus_impl<T1, T...>
+{
+ static const decltype(T1::value + mp_plus_impl<T...>::type::value) _v = T1::value + mp_plus_impl<T...>::type::value;
+ using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_plus_impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>
+{
+ static const
+ decltype(T1::value + T2::value + T3::value + T4::value + T5::value + T6::value + T7::value + T8::value + T9::value + T10::value + mp_plus_impl<T...>::type::value)
+ _v = T1::value + T2::value + T3::value + T4::value + T5::value + T6::value + T7::value + T8::value + T9::value + T10::value + mp_plus_impl<T...>::type::value;
+ using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+#else
+
+template<class T1, class... T> struct mp_plus_impl<T1, T...>
+{
+ static const auto _v = T1::value + mp_plus_impl<T...>::type::value;
+ using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_plus_impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>
+{
+ static const auto _v = T1::value + T2::value + T3::value + T4::value + T5::value + T6::value + T7::value + T8::value + T9::value + T10::value + mp_plus_impl<T...>::type::value;
+ using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+#endif
+
+#endif
+
+} // namespace detail
+
+template<class... T> using mp_plus = typename detail::mp_plus_impl<T...>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_PLUS_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_REMOVE_IF_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_REMOVE_IF_HPP_INCLUDED
+
+// Copyright 2015-2019 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
+
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_remove_if<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_remove_if_impl
+{
+};
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_remove_if_impl<L<T...>, P>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+ template<class U> struct _f { using type = mp_if<P<U>, mp_list<>, mp_list<U>>; };
+ using type = mp_append<L<>, typename _f<T>::type...>;
+#else
+ template<class U> using _f = mp_if<P<U>, mp_list<>, mp_list<U>>;
+ using type = mp_append<L<>, _f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_remove_if = typename detail::mp_remove_if_impl<L, P>::type;
+template<class L, class Q> using mp_remove_if_q = mp_remove_if<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_REMOVE_IF_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED
+
+// Copyright 2015-2021 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
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_rename<L, B>
+namespace detail
+{
+
+template<class A, template<class...> class B> struct mp_rename_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_rename is not a list
+};
+
+template<template<class...> class A, class... T, template<class...> class B> struct mp_rename_impl<A<T...>, B>
+{
+ using type = B<T...>;
+};
+
+} // namespace detail
+
+template<class A, template<class...> class B> using mp_rename = typename detail::mp_rename_impl<A, B>::type;
+
+template<template<class...> class F, class L> using mp_apply = typename detail::mp_rename_impl<L, F>::type;
+
+template<class Q, class L> using mp_apply_q = typename detail::mp_rename_impl<L, Q::template fn>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_VOID_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_VOID_HPP_INCLUDED
+
+// Copyright 2015-2017 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
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_void<T...>
+namespace detail
+{
+
+template<class... T> struct mp_void_impl
+{
+ using type = void;
+};
+
+} // namespace detail
+
+template<class... T> using mp_void = typename detail::mp_void_impl<T...>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_VOID_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
+
+// Copyright 2017 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
+
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <type_traits>
+#include <utility>
+#include <cassert>
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+# define BOOST_MP11_CONSTEXPR14 constexpr
+#else
+# define BOOST_MP11_CONSTEXPR14
+#endif
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+# define BOOST_MP11_UNREACHABLE_DEFAULT default: __builtin_unreachable();
+#elif defined( _MSC_VER )
+# define BOOST_MP11_UNREACHABLE_DEFAULT default: __assume(false);
+#else
+# define BOOST_MP11_UNREACHABLE_DEFAULT
+#endif
+
+namespace boost
+{
+namespace mp11
+{
+
+namespace detail
+{
+
+template<std::size_t N> struct mp_with_index_impl_
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ if( i < N / 2 )
+ {
+ return mp_with_index_impl_<N/2>::template call<K>( i, std::forward<F>(f) );
+ }
+ else
+ {
+ return mp_with_index_impl_<N-N/2>::template call<K+N/2>( i - N/2, std::forward<F>(f) );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<0>
+{
+};
+
+template<> struct mp_with_index_impl_<1>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t /*i*/, F && f )
+ {
+ return std::forward<F>(f)( mp_size_t<K+0>() );
+ }
+};
+
+template<> struct mp_with_index_impl_<2>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<3>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<4>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<5>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<6>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<7>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<8>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<9>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<10>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+ case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<11>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+ case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+ case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<12>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+ case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+ case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+ case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<13>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+ case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+ case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+ case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+ case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<14>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+ case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+ case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+ case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+ case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
+ case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<15>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+ case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+ case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+ case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+ case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
+ case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
+ case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
+ }
+ }
+};
+
+template<> struct mp_with_index_impl_<16>
+{
+ template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+ {
+ switch( i )
+ {
+ BOOST_MP11_UNREACHABLE_DEFAULT
+ case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+ case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+ case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+ case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+ case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+ case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+ case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+ case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+ case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+ case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+ case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+ case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+ case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
+ case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
+ case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
+ case 15: return std::forward<F>(f)( mp_size_t<K+15>() );
+ }
+ }
+};
+
+} // namespace detail
+
+template<std::size_t N, class F> inline BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
+{
+ assert( i < N );
+ return detail::mp_with_index_impl_<N>::template call<0>( i, std::forward<F>(f) );
+}
+
+template<class N, class F> inline BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
+{
+ return mp_with_index<std::size_t{N::value}>( i, std::forward<F>(f) );
+}
+
+#undef BOOST_MP11_CONSTEXPR14
+#undef BOOST_MP11_UNREACHABLE_DEFAULT
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_FUNCTION_HPP_INCLUDED
+#define BOOST_MP11_FUNCTION_HPP_INCLUDED
+
+// Copyright 2015-2019 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
+
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_count.hpp>
+#include <boost/mp11/detail/mp_plus.hpp>
+#include <boost/mp11/detail/mp_min_element.hpp>
+#include <boost/mp11/detail/mp_void.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_void<T...>
+// in detail/mp_void.hpp
+
+// mp_and<T...>
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1910 )
+
+namespace detail
+{
+
+template<class... T> struct mp_and_impl;
+
+} // namespace detail
+
+template<class... T> using mp_and = mp_to_bool< typename detail::mp_and_impl<T...>::type >;
+
+namespace detail
+{
+
+template<> struct mp_and_impl<>
+{
+ using type = mp_true;
+};
+
+template<class T> struct mp_and_impl<T>
+{
+ using type = T;
+};
+
+template<class T1, class... T> struct mp_and_impl<T1, T...>
+{
+ using type = mp_eval_if< mp_not<T1>, T1, mp_and, T... >;
+};
+
+} // namespace detail
+
+#else
+
+namespace detail
+{
+
+template<class L, class E = void> struct mp_and_impl
+{
+ using type = mp_false;
+};
+
+template<class... T> struct mp_and_impl< mp_list<T...>, mp_void<mp_if<T, void>...> >
+{
+ using type = mp_true;
+};
+
+} // namespace detail
+
+template<class... T> using mp_and = typename detail::mp_and_impl<mp_list<T...>>::type;
+
+#endif
+
+// mp_all<T...>
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86355
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, != 0 )
+
+template<class... T> using mp_all = mp_bool< mp_count_if< mp_list<T...>, mp_not >::value == 0 >;
+
+#else
+
+template<class... T> using mp_all = mp_bool< mp_count< mp_list<mp_to_bool<T>...>, mp_false >::value == 0 >;
+
+#endif
+
+// mp_or<T...>
+namespace detail
+{
+
+template<class... T> struct mp_or_impl;
+
+} // namespace detail
+
+template<class... T> using mp_or = mp_to_bool< typename detail::mp_or_impl<T...>::type >;
+
+namespace detail
+{
+
+template<> struct mp_or_impl<>
+{
+ using type = mp_false;
+};
+
+template<class T> struct mp_or_impl<T>
+{
+ using type = T;
+};
+
+template<class T1, class... T> struct mp_or_impl<T1, T...>
+{
+ using type = mp_eval_if< T1, T1, mp_or, T... >;
+};
+
+} // namespace detail
+
+// mp_any<T...>
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86356
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, != 0 )
+
+template<class... T> using mp_any = mp_bool< mp_count_if< mp_list<T...>, mp_to_bool >::value != 0 >;
+
+#else
+
+template<class... T> using mp_any = mp_bool< mp_count< mp_list<mp_to_bool<T>...>, mp_true >::value != 0 >;
+
+#endif
+
+// mp_same<T...>
+namespace detail
+{
+
+template<class... T> struct mp_same_impl;
+
+template<> struct mp_same_impl<>
+{
+ using type = mp_true;
+};
+
+template<class T1, class... T> struct mp_same_impl<T1, T...>
+{
+ using type = mp_bool< mp_count<mp_list<T...>, T1>::value == sizeof...(T) >;
+};
+
+} // namespace detail
+
+template<class... T> using mp_same = typename detail::mp_same_impl<T...>::type;
+
+// mp_similar<T...>
+namespace detail
+{
+
+template<class... T> struct mp_similar_impl;
+
+template<> struct mp_similar_impl<>
+{
+ using type = mp_true;
+};
+
+template<class T> struct mp_similar_impl<T>
+{
+ using type = mp_true;
+};
+
+template<class T> struct mp_similar_impl<T, T>
+{
+ using type = mp_true;
+};
+
+template<class T1, class T2> struct mp_similar_impl<T1, T2>
+{
+ using type = mp_false;
+};
+
+template<template<class...> class L, class... T1, class... T2> struct mp_similar_impl<L<T1...>, L<T2...>>
+{
+ using type = mp_true;
+};
+
+template<template<class...> class L, class... T> struct mp_similar_impl<L<T...>, L<T...>>
+{
+ using type = mp_true;
+};
+
+template<class T1, class T2, class T3, class... T> struct mp_similar_impl<T1, T2, T3, T...>
+{
+ using type = mp_all< typename mp_similar_impl<T1, T2>::type, typename mp_similar_impl<T1, T3>::type, typename mp_similar_impl<T1, T>::type... >;
+};
+
+} // namespace detail
+
+template<class... T> using mp_similar = typename detail::mp_similar_impl<T...>::type;
+
+#if BOOST_MP11_GCC
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+// mp_less<T1, T2>
+template<class T1, class T2> using mp_less = mp_bool<(T1::value < 0 && T2::value >= 0) || ((T1::value < T2::value) && !(T1::value >= 0 && T2::value < 0))>;
+
+#if BOOST_MP11_GCC
+# pragma GCC diagnostic pop
+#endif
+
+// mp_min<T...>
+template<class T1, class... T> using mp_min = mp_min_element<mp_list<T1, T...>, mp_less>;
+
+// mp_max<T...>
+template<class T1, class... T> using mp_max = mp_max_element<mp_list<T1, T...>, mp_less>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_FUNCTION_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED
+#define BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED
+
+// Copyright 2015, 2017, 2019 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
+
+#include <boost/mp11/version.hpp>
+#include <cstddef>
+
+#if defined(__has_builtin)
+# if __has_builtin(__make_integer_seq)
+# define BOOST_MP11_HAS_MAKE_INTEGER_SEQ
+# endif
+#endif
+
+namespace boost
+{
+namespace mp11
+{
+
+// integer_sequence
+template<class T, T... I> struct integer_sequence
+{
+};
+
+#if defined(BOOST_MP11_HAS_MAKE_INTEGER_SEQ)
+
+template<class T, T N> using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
+
+#else
+
+// detail::make_integer_sequence_impl
+namespace detail
+{
+
+// iseq_if_c
+template<bool C, class T, class E> struct iseq_if_c_impl;
+
+template<class T, class E> struct iseq_if_c_impl<true, T, E>
+{
+ using type = T;
+};
+
+template<class T, class E> struct iseq_if_c_impl<false, T, E>
+{
+ using type = E;
+};
+
+template<bool C, class T, class E> using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
+
+// iseq_identity
+template<class T> struct iseq_identity
+{
+ using type = T;
+};
+
+template<class S1, class S2> struct append_integer_sequence;
+
+template<class T, T... I, T... J> struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
+{
+ using type = integer_sequence< T, I..., ( J + sizeof...(I) )... >;
+};
+
+template<class T, T N> struct make_integer_sequence_impl;
+
+template<class T, T N> struct make_integer_sequence_impl_
+{
+private:
+
+ static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
+
+ static T const M = N / 2;
+ static T const R = N % 2;
+
+ using S1 = typename make_integer_sequence_impl<T, M>::type;
+ using S2 = typename append_integer_sequence<S1, S1>::type;
+ using S3 = typename make_integer_sequence_impl<T, R>::type;
+ using S4 = typename append_integer_sequence<S2, S3>::type;
+
+public:
+
+ using type = S4;
+};
+
+template<class T, T N> struct make_integer_sequence_impl: iseq_if_c<N == 0, iseq_identity<integer_sequence<T>>, iseq_if_c<N == 1, iseq_identity<integer_sequence<T, 0>>, make_integer_sequence_impl_<T, N> > >
+{
+};
+
+} // namespace detail
+
+// make_integer_sequence
+template<class T, T N> using make_integer_sequence = typename detail::make_integer_sequence_impl<T, N>::type;
+
+#endif // defined(BOOST_MP11_HAS_MAKE_INTEGER_SEQ)
+
+// index_sequence
+template<std::size_t... I> using index_sequence = integer_sequence<std::size_t, I...>;
+
+// make_index_sequence
+template<std::size_t N> using make_index_sequence = make_integer_sequence<std::size_t, N>;
+
+// index_sequence_for
+template<class... T> using index_sequence_for = make_integer_sequence<std::size_t, sizeof...(T)>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_INTEGRAL_HPP_INCLUDED
+#define BOOST_MP11_INTEGRAL_HPP_INCLUDED
+
+// Copyright 2015 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
+
+#include <boost/mp11/version.hpp>
+#include <type_traits>
+#include <cstddef>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_bool
+template<bool B> using mp_bool = std::integral_constant<bool, B>;
+
+using mp_true = mp_bool<true>;
+using mp_false = mp_bool<false>;
+
+// mp_to_bool
+template<class T> using mp_to_bool = mp_bool<static_cast<bool>( T::value )>;
+
+// mp_not<T>
+template<class T> using mp_not = mp_bool< !T::value >;
+
+// mp_int
+template<int I> using mp_int = std::integral_constant<int, I>;
+
+// mp_size_t
+template<std::size_t N> using mp_size_t = std::integral_constant<std::size_t, N>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_INTEGRAL_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_LIST_HPP_INCLUDED
+#define BOOST_MP11_LIST_HPP_INCLUDED
+
+// Copyright 2015-2017 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
+
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_is_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/mp_front.hpp>
+#include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_list_c<T, I...>
+template<class T, T... I> using mp_list_c = mp_list<std::integral_constant<T, I>...>;
+
+// mp_is_list<L>
+// in detail/mp_is_list.hpp
+
+// mp_size<L>
+namespace detail
+{
+
+template<class L> struct mp_size_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_size is not a list
+};
+
+template<template<class...> class L, class... T> struct mp_size_impl<L<T...>>
+{
+ using type = mp_size_t<sizeof...(T)>;
+};
+
+} // namespace detail
+
+template<class L> using mp_size = typename detail::mp_size_impl<L>::type;
+
+// mp_empty<L>
+template<class L> using mp_empty = mp_bool< mp_size<L>::value == 0 >;
+
+// mp_assign<L1, L2>
+namespace detail
+{
+
+template<class L1, class L2> struct mp_assign_impl;
+
+template<template<class...> class L1, class... T, template<class...> class L2, class... U> struct mp_assign_impl<L1<T...>, L2<U...>>
+{
+ using type = L1<U...>;
+};
+
+} // namespace detail
+
+template<class L1, class L2> using mp_assign = typename detail::mp_assign_impl<L1, L2>::type;
+
+// mp_clear<L>
+template<class L> using mp_clear = mp_assign<L, mp_list<>>;
+
+// mp_front<L>
+// in detail/mp_front.hpp
+
+// mp_pop_front<L>
+namespace detail
+{
+
+template<class L> struct mp_pop_front_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_pop_front
+// is either not a list, or is an empty list
+};
+
+template<template<class...> class L, class T1, class... T> struct mp_pop_front_impl<L<T1, T...>>
+{
+ using type = L<T...>;
+};
+
+} // namespace detail
+
+template<class L> using mp_pop_front = typename detail::mp_pop_front_impl<L>::type;
+
+// mp_first<L>
+template<class L> using mp_first = mp_front<L>;
+
+// mp_rest<L>
+template<class L> using mp_rest = mp_pop_front<L>;
+
+// mp_second<L>
+namespace detail
+{
+
+template<class L> struct mp_second_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_second
+// is either not a list, or has fewer than two elements
+};
+
+template<template<class...> class L, class T1, class T2, class... T> struct mp_second_impl<L<T1, T2, T...>>
+{
+ using type = T2;
+};
+
+} // namespace detail
+
+template<class L> using mp_second = typename detail::mp_second_impl<L>::type;
+
+// mp_third<L>
+namespace detail
+{
+
+template<class L> struct mp_third_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_third
+// is either not a list, or has fewer than three elements
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class... T> struct mp_third_impl<L<T1, T2, T3, T...>>
+{
+ using type = T3;
+};
+
+} // namespace detail
+
+template<class L> using mp_third = typename detail::mp_third_impl<L>::type;
+
+// mp_push_front<L, T...>
+namespace detail
+{
+
+template<class L, class... T> struct mp_push_front_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_push_front is not a list
+};
+
+template<template<class...> class L, class... U, class... T> struct mp_push_front_impl<L<U...>, T...>
+{
+ using type = L<T..., U...>;
+};
+
+} // namespace detail
+
+template<class L, class... T> using mp_push_front = typename detail::mp_push_front_impl<L, T...>::type;
+
+// mp_push_back<L, T...>
+namespace detail
+{
+
+template<class L, class... T> struct mp_push_back_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_push_back is not a list
+};
+
+template<template<class...> class L, class... U, class... T> struct mp_push_back_impl<L<U...>, T...>
+{
+ using type = L<U..., T...>;
+};
+
+} // namespace detail
+
+template<class L, class... T> using mp_push_back = typename detail::mp_push_back_impl<L, T...>::type;
+
+// mp_rename<L, B>
+// mp_apply<F, L>
+// mp_apply_q<Q, L>
+// in detail/mp_rename.hpp
+
+// mp_replace_front<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_front_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_replace_front
+// is either not a list, or is an empty list
+};
+
+template<template<class...> class L, class U1, class... U, class T> struct mp_replace_front_impl<L<U1, U...>, T>
+{
+ using type = L<T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_front = typename detail::mp_replace_front_impl<L, T>::type;
+
+// mp_replace_first<L, T>
+template<class L, class T> using mp_replace_first = typename detail::mp_replace_front_impl<L, T>::type;
+
+// mp_replace_second<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_second_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_replace_second
+// is either not a list, or has fewer than two elements
+};
+
+template<template<class...> class L, class U1, class U2, class... U, class T> struct mp_replace_second_impl<L<U1, U2, U...>, T>
+{
+ using type = L<U1, T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_second = typename detail::mp_replace_second_impl<L, T>::type;
+
+// mp_replace_third<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_third_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_replace_third
+// is either not a list, or has fewer than three elements
+};
+
+template<template<class...> class L, class U1, class U2, class U3, class... U, class T> struct mp_replace_third_impl<L<U1, U2, U3, U...>, T>
+{
+ using type = L<U1, U2, T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_third = typename detail::mp_replace_third_impl<L, T>::type;
+
+// mp_transform_front<L, F>
+namespace detail
+{
+
+template<class L, template<class...> class F> struct mp_transform_front_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_transform_front
+// is either not a list, or is an empty list
+};
+
+template<template<class...> class L, class U1, class... U, template<class...> class F> struct mp_transform_front_impl<L<U1, U...>, F>
+{
+ using type = L<F<U1>, U...>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class F> using mp_transform_front = typename detail::mp_transform_front_impl<L, F>::type;
+template<class L, class Q> using mp_transform_front_q = mp_transform_front<L, Q::template fn>;
+
+// mp_transform_first<L, F>
+template<class L, template<class...> class F> using mp_transform_first = typename detail::mp_transform_front_impl<L, F>::type;
+template<class L, class Q> using mp_transform_first_q = mp_transform_first<L, Q::template fn>;
+
+// mp_transform_second<L, F>
+namespace detail
+{
+
+template<class L, template<class...> class F> struct mp_transform_second_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_transform_second
+// is either not a list, or has fewer than two elements
+};
+
+template<template<class...> class L, class U1, class U2, class... U, template<class...> class F> struct mp_transform_second_impl<L<U1, U2, U...>, F>
+{
+ using type = L<U1, F<U2>, U...>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class F> using mp_transform_second = typename detail::mp_transform_second_impl<L, F>::type;
+template<class L, class Q> using mp_transform_second_q = mp_transform_second<L, Q::template fn>;
+
+// mp_transform_third<L, F>
+namespace detail
+{
+
+template<class L, template<class...> class F> struct mp_transform_third_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_transform_third
+// is either not a list, or has fewer than three elements
+};
+
+template<template<class...> class L, class U1, class U2, class U3, class... U, template<class...> class F> struct mp_transform_third_impl<L<U1, U2, U3, U...>, F>
+{
+ using type = L<U1, U2, F<U3>, U...>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class F> using mp_transform_third = typename detail::mp_transform_third_impl<L, F>::type;
+template<class L, class Q> using mp_transform_third_q = mp_transform_third<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_LIST_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_SET_HPP_INCLUDED
+#define BOOST_MP11_SET_HPP_INCLUDED
+
+// Copyright 2015, 2019 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
+
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/mp_copy_if.hpp>
+#include <boost/mp11/detail/mp_remove_if.hpp>
+#include <boost/mp11/detail/mp_is_list.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_set_contains<S, V>
+namespace detail
+{
+
+template<class S, class V> struct mp_set_contains_impl
+{
+};
+
+template<template<class...> class L, class... T, class V> struct mp_set_contains_impl<L<T...>, V>
+{
+ using type = mp_to_bool<std::is_base_of<mp_identity<V>, mp_inherit<mp_identity<T>...> > >;
+};
+
+} // namespace detail
+
+template<class S, class V> using mp_set_contains = typename detail::mp_set_contains_impl<S, V>::type;
+
+// mp_set_push_back<S, T...>
+namespace detail
+{
+
+template<class S, class... T> struct mp_set_push_back_impl
+{
+};
+
+template<template<class...> class L, class... U> struct mp_set_push_back_impl<L<U...>>
+{
+ using type = L<U...>;
+};
+
+template<template<class...> class L, class... U, class T1, class... T> struct mp_set_push_back_impl<L<U...>, T1, T...>
+{
+ using S = mp_if<mp_set_contains<L<U...>, T1>, L<U...>, L<U..., T1>>;
+ using type = typename mp_set_push_back_impl<S, T...>::type;
+};
+
+} // namespace detail
+
+template<class S, class... T> using mp_set_push_back = typename detail::mp_set_push_back_impl<S, T...>::type;
+
+// mp_set_push_front<S, T...>
+namespace detail
+{
+
+template<class S, class... T> struct mp_set_push_front_impl
+{
+};
+
+template<template<class...> class L, class... U> struct mp_set_push_front_impl<L<U...>>
+{
+ using type = L<U...>;
+};
+
+template<template<class...> class L, class... U, class T1> struct mp_set_push_front_impl<L<U...>, T1>
+{
+ using type = mp_if<mp_set_contains<L<U...>, T1>, L<U...>, L<T1, U...>>;
+};
+
+template<template<class...> class L, class... U, class T1, class... T> struct mp_set_push_front_impl<L<U...>, T1, T...>
+{
+ using S = typename mp_set_push_front_impl<L<U...>, T...>::type;
+ using type = typename mp_set_push_front_impl<S, T1>::type;
+};
+
+} // namespace detail
+
+template<class S, class... T> using mp_set_push_front = typename detail::mp_set_push_front_impl<S, T...>::type;
+
+// mp_is_set<S>
+namespace detail
+{
+
+template<class S> struct mp_is_set_impl
+{
+ using type = mp_false;
+};
+
+template<template<class...> class L, class... T> struct mp_is_set_impl<L<T...>>
+{
+ using type = mp_to_bool<std::is_same<mp_list<T...>, mp_set_push_back<mp_list<>, T...> > >;
+};
+
+} // namespace detail
+
+template<class S> using mp_is_set = typename detail::mp_is_set_impl<S>::type;
+
+// mp_set_union<L...>
+namespace detail
+{
+
+template<class... L> struct mp_set_union_impl
+{
+};
+
+template<> struct mp_set_union_impl<>
+{
+ using type = mp_list<>;
+};
+
+template<template<class...> class L, class... T> struct mp_set_union_impl<L<T...>>
+{
+ using type = L<T...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_set_union_impl<L1<T1...>, L2<T2...>>
+{
+ using type = mp_set_push_back<L1<T1...>, T2...>;
+};
+
+template<class L1, class... L> using mp_set_union_ = typename mp_set_union_impl<L1, mp_append<mp_list<>, L...>>::type;
+
+template<class L1, class L2, class L3, class... L> struct mp_set_union_impl<L1, L2, L3, L...>: mp_defer<mp_set_union_, L1, L2, L3, L...>
+{
+};
+
+} // namespace detail
+
+template<class... L> using mp_set_union = typename detail::mp_set_union_impl<L...>::type;
+
+// mp_set_intersection<S...>
+namespace detail
+{
+
+template<class... S> struct in_all_sets
+{
+ template<class T> using fn = mp_all< mp_set_contains<S, T>... >;
+};
+
+template<class L, class... S> using mp_set_intersection_ = mp_if< mp_all<mp_is_list<S>...>, mp_copy_if_q<L, detail::in_all_sets<S...>> >;
+
+template<class... S> struct mp_set_intersection_impl
+{
+};
+
+template<> struct mp_set_intersection_impl<>
+{
+ using type = mp_list<>;
+};
+
+template<class L, class... S> struct mp_set_intersection_impl<L, S...>: mp_defer<mp_set_intersection_, L, S...>
+{
+};
+
+} // namespace detail
+
+template<class... S> using mp_set_intersection = typename detail::mp_set_intersection_impl<S...>::type;
+
+// mp_set_difference<L, S...>
+namespace detail
+{
+
+template<class... S> struct in_any_set
+{
+ template<class T> using fn = mp_any< mp_set_contains<S, T>... >;
+};
+
+} // namespace detail
+
+template<class L, class... S> using mp_set_difference = mp_if< mp_all<mp_is_list<S>...>, mp_remove_if_q<L, detail::in_any_set<S...>> >;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_SET_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_UTILITY_HPP_INCLUDED
+#define BOOST_MP11_UTILITY_HPP_INCLUDED
+
+// Copyright 2015-2020 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
+
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_fold.hpp>
+#include <boost/mp11/detail/mp_front.hpp>
+#include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_identity
+template<class T> struct mp_identity
+{
+ using type = T;
+};
+
+// mp_identity_t
+template<class T> using mp_identity_t = typename mp_identity<T>::type;
+
+// mp_inherit
+template<class... T> struct mp_inherit: T... {};
+
+// mp_if, mp_if_c
+namespace detail
+{
+
+template<bool C, class T, class... E> struct mp_if_c_impl
+{
+};
+
+template<class T, class... E> struct mp_if_c_impl<true, T, E...>
+{
+ using type = T;
+};
+
+template<class T, class E> struct mp_if_c_impl<false, T, E>
+{
+ using type = E;
+};
+
+} // namespace detail
+
+template<bool C, class T, class... E> using mp_if_c = typename detail::mp_if_c_impl<C, T, E...>::type;
+template<class C, class T, class... E> using mp_if = typename detail::mp_if_c_impl<static_cast<bool>(C::value), T, E...>::type;
+
+// mp_valid
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_INTEL, != 0 ) // tested at 1800
+
+// contributed by Roland Schulz in https://github.com/boostorg/mp11/issues/17
+
+namespace detail
+{
+
+template<class...> using void_t = void;
+
+template<class, template<class...> class F, class... T>
+struct mp_valid_impl: mp_false {};
+
+template<template<class...> class F, class... T>
+struct mp_valid_impl<void_t<F<T...>>, F, T...>: mp_true {};
+
+} // namespace detail
+
+template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<void, F, T...>;
+
+#else
+
+// implementation by Bruno Dutra (by the name is_evaluable)
+namespace detail
+{
+
+template<template<class...> class F, class... T> struct mp_valid_impl
+{
+ template<template<class...> class G, class = G<T...>> static mp_true check(int);
+ template<template<class...> class> static mp_false check(...);
+
+ using type = decltype(check<F>(0));
+};
+
+} // namespace detail
+
+template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<F, T...>::type;
+
+#endif
+
+template<class Q, class... T> using mp_valid_q = mp_valid<Q::template fn, T...>;
+
+// mp_defer
+namespace detail
+{
+
+template<template<class...> class F, class... T> struct mp_defer_impl
+{
+ using type = F<T...>;
+};
+
+struct mp_no_type
+{
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... T> struct mp_defer_cuda_workaround
+{
+ using type = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
+};
+
+#endif
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... T> using mp_defer = typename detail::mp_defer_cuda_workaround< F, T...>::type;
+
+#else
+
+template<template<class...> class F, class... T> using mp_defer = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
+
+#endif
+
+// mp_eval_if, mp_eval_if_c
+namespace detail
+{
+
+template<bool C, class T, template<class...> class F, class... U> struct mp_eval_if_c_impl;
+
+template<class T, template<class...> class F, class... U> struct mp_eval_if_c_impl<true, T, F, U...>
+{
+ using type = T;
+};
+
+template<class T, template<class...> class F, class... U> struct mp_eval_if_c_impl<false, T, F, U...>: mp_defer<F, U...>
+{
+};
+
+} // namespace detail
+
+template<bool C, class T, template<class...> class F, class... U> using mp_eval_if_c = typename detail::mp_eval_if_c_impl<C, T, F, U...>::type;
+template<class C, class T, template<class...> class F, class... U> using mp_eval_if = typename detail::mp_eval_if_c_impl<static_cast<bool>(C::value), T, F, U...>::type;
+template<class C, class T, class Q, class... U> using mp_eval_if_q = typename detail::mp_eval_if_c_impl<static_cast<bool>(C::value), T, Q::template fn, U...>::type;
+
+// mp_eval_if_not
+template<class C, class T, template<class...> class F, class... U> using mp_eval_if_not = mp_eval_if<mp_not<C>, T, F, U...>;
+template<class C, class T, class Q, class... U> using mp_eval_if_not_q = mp_eval_if<mp_not<C>, T, Q::template fn, U...>;
+
+// mp_eval_or
+template<class T, template<class...> class F, class... U> using mp_eval_or = mp_eval_if_not<mp_valid<F, U...>, T, F, U...>;
+template<class T, class Q, class... U> using mp_eval_or_q = mp_eval_or<T, Q::template fn, U...>;
+
+// mp_valid_and_true
+template<template<class...> class F, class... T> using mp_valid_and_true = mp_eval_or<mp_false, F, T...>;
+template<class Q, class... T> using mp_valid_and_true_q = mp_valid_and_true<Q::template fn, T...>;
+
+// mp_cond
+
+// so elegant; so doesn't work
+// template<class C, class T, class... E> using mp_cond = mp_eval_if<C, T, mp_cond, E...>;
+
+namespace detail
+{
+
+template<class C, class T, class... E> struct mp_cond_impl;
+
+} // namespace detail
+
+template<class C, class T, class... E> using mp_cond = typename detail::mp_cond_impl<C, T, E...>::type;
+
+namespace detail
+{
+
+template<class C, class T, class... E> using mp_cond_ = mp_eval_if<C, T, mp_cond, E...>;
+
+template<class C, class T, class... E> struct mp_cond_impl: mp_defer<mp_cond_, C, T, E...>
+{
+};
+
+} // namespace detail
+
+// mp_quote
+template<template<class...> class F> struct mp_quote
+{
+ // the indirection through mp_defer works around the language inability
+ // to expand T... into a fixed parameter list of an alias template
+
+ template<class... T> using fn = typename mp_defer<F, T...>::type;
+};
+
+// mp_quote_trait
+template<template<class...> class F> struct mp_quote_trait
+{
+ template<class... T> using fn = typename F<T...>::type;
+};
+
+// mp_invoke_q
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+namespace detail
+{
+
+template<class Q, class... T> struct mp_invoke_q_impl: mp_defer<Q::template fn, T...> {};
+
+} // namespace detail
+
+template<class Q, class... T> using mp_invoke_q = typename detail::mp_invoke_q_impl<Q, T...>::type;
+
+#elif BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 50000 )
+
+template<class Q, class... T> using mp_invoke_q = typename mp_defer<Q::template fn, T...>::type;
+
+#else
+
+template<class Q, class... T> using mp_invoke_q = typename Q::template fn<T...>;
+
+#endif
+
+// mp_not_fn<P>
+template<template<class...> class P> struct mp_not_fn
+{
+ template<class... T> using fn = mp_not< mp_invoke_q<mp_quote<P>, T...> >;
+};
+
+template<class Q> using mp_not_fn_q = mp_not_fn<Q::template fn>;
+
+// mp_compose
+namespace detail
+{
+
+template<class L, class Q> using mp_compose_helper = mp_list< mp_apply_q<Q, L> >;
+
+} // namespace detail
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+template<template<class...> class... F> struct mp_compose
+{
+ template<class... T> using fn = mp_front< mp_fold<mp_list<mp_quote<F>...>, mp_list<T...>, detail::mp_compose_helper> >;
+};
+
+#endif
+
+template<class... Q> struct mp_compose_q
+{
+ template<class... T> using fn = mp_front< mp_fold<mp_list<Q...>, mp_list<T...>, detail::mp_compose_helper> >;
+};
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_UTILITY_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_MP11_VERSION_HPP_INCLUDED
+#define BOOST_MP11_VERSION_HPP_INCLUDED
+
+// Copyright 2019 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
+
+// Same format as BOOST_VERSION:
+// major * 100000 + minor * 100 + patch
+
+#define BOOST_MP11_VERSION 108100
+
+#endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002-2011. *
-# * (C) Copyright Edward Diener 2011. *
+# * (C) Copyright Edward Diener 2011-2020. *
# * 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) *
#
# /* BOOST_PP_VARIADICS */
#
-# define BOOST_PP_VARIADICS_MSVC 0
-# if !defined BOOST_PP_VARIADICS
-# /* variadic support explicitly disabled for all untested compilers */
-
-# if defined __GCCXML__ || (defined __CUDACC__ && !(defined(__clang__) && defined(__CUDA__))) || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || ( defined __SUNPRO_CC && __SUNPRO_CC < 0x5120 ) || (defined __HP_aCC && !defined __EDG__) || defined __MRC__ || defined __SC__ || (defined(__PGI) && !defined(__EDG__))
-# define BOOST_PP_VARIADICS 0
-# elif defined(_MSC_VER) && defined(__clang__)
-# define BOOST_PP_VARIADICS 1
-# /* VC++ (C/C++) and Intel C++ Compiler >= 17.0 with MSVC */
-# elif defined _MSC_VER && _MSC_VER >= 1400 && (!defined __EDG__ || defined(__INTELLISENSE__) || defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700)
-# define BOOST_PP_VARIADICS 1
-# if !defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL
-# undef BOOST_PP_VARIADICS_MSVC
-# define BOOST_PP_VARIADICS_MSVC 1
-# endif
-# /* Wave (C/C++), GCC (C++) */
-# elif defined __WAVE__ && __WAVE_HAS_VARIADICS__ || defined __GNUC__ && defined __GXX_EXPERIMENTAL_CXX0X__ && __GXX_EXPERIMENTAL_CXX0X__
-# define BOOST_PP_VARIADICS 1
-# /* EDG-based (C/C++), GCC (C), and unknown (C/C++) */
-# elif !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L
-# define BOOST_PP_VARIADICS 1
-# else
-# define BOOST_PP_VARIADICS 0
-# endif
-# elif !BOOST_PP_VARIADICS + 1 < 2
+# if defined BOOST_PP_VARIADICS
# undef BOOST_PP_VARIADICS
-# define BOOST_PP_VARIADICS 1
-# if defined _MSC_VER && _MSC_VER >= 1400 && !defined(__clang__) && (defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI)) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL)
-# undef BOOST_PP_VARIADICS_MSVC
-# define BOOST_PP_VARIADICS_MSVC 1
-# endif
+# endif
+# if defined BOOST_PP_VARIADICS_MSVC
+# undef BOOST_PP_VARIADICS_MSVC
+# endif
+# define BOOST_PP_VARIADICS 1
+# if defined _MSC_VER && _MSC_VER >= 1400 && !defined(__clang__) && (defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) || !(defined __EDG__ || defined __GCCXML__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI)) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL)
+# define BOOST_PP_VARIADICS_MSVC 1
# else
-# undef BOOST_PP_VARIADICS
-# define BOOST_PP_VARIADICS 0
+# define BOOST_PP_VARIADICS_MSVC 0
+# endif
+#
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT()
+# define BOOST_PP_IS_STANDARD() 1
+# else
+# define BOOST_PP_IS_STANDARD() 0
# endif
#
# endif
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
+#include <cstddef> //for std::size_t
#if defined(__GNUC__) && !defined(__GXX_EXPERIMENTAL_CXX0X__)
//
# define BOOST_STATIC_ASSERT_MSG( B, Msg ) BOOST_STATIC_ASSERT( B )
#endif
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
//
// workaround for buggy integral-constant expression support:
#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
// HP aCC cannot deal with missing names for template value parameters
-template<int x> struct static_assert_test{};
+template<std::size_t x> struct static_assert_test{};
}
+++ /dev/null
-/*
- * Copyright (c) 2014 Glen Fernandes
- *
- * 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_SWAP_HPP
-#define BOOST_SWAP_HPP
-
-// The header file at this path is deprecated;
-// use boost/core/swap.hpp instead.
-
-#include <boost/core/swap.hpp>
-
-#endif
-#ifndef UUID_AA15E74A856F11E08B8D93F24824019B
-#define UUID_AA15E74A856F11E08B8D93F24824019B
+#ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED
+#define BOOST_THROW_EXCEPTION_HPP_INCLUDED
// MS compatible compilers support #pragma once
# pragma once
#endif
-//
// boost/throw_exception.hpp
//
-// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+// Copyright (c) 2002, 2018-2022 Peter Dimov
// Copyright (c) 2008-2009 Emil Dotchevski and Reverge Studios, Inc.
//
// 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)
//
-// http://www.boost.org/libs/utility/throw_exception.html
-//
+// http://www.boost.org/libs/throw_exception
+#include <boost/exception/exception.hpp>
+#include <boost/assert/source_location.hpp>
#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
#include <exception>
-
-#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x593) )
-# define BOOST_EXCEPTION_DISABLE
+#include <utility>
+#include <cstddef>
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#include <type_traits>
#endif
-#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1310 )
+#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( BOOST_BORLANDC ) && BOOST_WORKAROUND( BOOST_BORLANDC, BOOST_TESTED_AT(0x593) )
# define BOOST_EXCEPTION_DISABLE
#endif
-#if !defined( BOOST_EXCEPTION_DISABLE )
-# include <boost/exception/exception.hpp>
-#if !defined(BOOST_THROW_EXCEPTION_CURRENT_FUNCTION)
-# include <boost/current_function.hpp>
-# define BOOST_THROW_EXCEPTION_CURRENT_FUNCTION BOOST_CURRENT_FUNCTION
+namespace boost
+{
+
+#if defined( BOOST_NO_EXCEPTIONS )
+
+BOOST_NORETURN void throw_exception( std::exception const & e ); // user defined
+BOOST_NORETURN void throw_exception( std::exception const & e, boost::source_location const & loc ); // user defined
+
#endif
-# define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_THROW_EXCEPTION_CURRENT_FUNCTION,__FILE__,__LINE__)
+
+// boost::wrapexcept<E>
+
+namespace detail
+{
+
+typedef char (&wrapexcept_s1)[ 1 ];
+typedef char (&wrapexcept_s2)[ 2 ];
+
+template<class T> wrapexcept_s1 wrapexcept_is_convertible( T* );
+template<class T> wrapexcept_s2 wrapexcept_is_convertible( void* );
+
+template<class E, class B, std::size_t I = sizeof( wrapexcept_is_convertible<B>( static_cast< E* >( BOOST_NULLPTR ) ) ) > struct wrapexcept_add_base;
+
+template<class E, class B> struct wrapexcept_add_base<E, B, 1>
+{
+ struct type {};
+};
+
+template<class E, class B> struct wrapexcept_add_base<E, B, 2>
+{
+ typedef B type;
+};
+
+} // namespace detail
+
+template<class E> struct BOOST_SYMBOL_VISIBLE wrapexcept:
+ public detail::wrapexcept_add_base<E, boost::exception_detail::clone_base>::type,
+ public E,
+ public detail::wrapexcept_add_base<E, boost::exception>::type
+{
+private:
+
+ struct deleter
+ {
+ wrapexcept * p_;
+ ~deleter() { delete p_; }
+ };
+
+private:
+
+ void copy_from( void const* )
+ {
+ }
+
+ void copy_from( boost::exception const* p )
+ {
+ static_cast<boost::exception&>( *this ) = *p;
+ }
+
+public:
+
+ explicit wrapexcept( E const & e ): E( e )
+ {
+ copy_from( &e );
+ }
+
+ explicit wrapexcept( E const & e, boost::source_location const & loc ): E( e )
+ {
+ copy_from( &e );
+
+ set_info( *this, throw_file( loc.file_name() ) );
+ set_info( *this, throw_line( loc.line() ) );
+ set_info( *this, throw_function( loc.function_name() ) );
+ set_info( *this, throw_column( loc.column() ) );
+ }
+
+ virtual boost::exception_detail::clone_base const * clone() const BOOST_OVERRIDE
+ {
+ wrapexcept * p = new wrapexcept( *this );
+ deleter del = { p };
+
+ boost::exception_detail::copy_boost_exception( p, this );
+
+ del.p_ = BOOST_NULLPTR;
+ return p;
+ }
+
+ virtual void rethrow() const BOOST_OVERRIDE
+ {
+#if defined( BOOST_NO_EXCEPTIONS )
+
+ boost::throw_exception( *this );
+
#else
-# define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x)
-#endif
-#if defined(__GNUC__) && (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma GCC system_header
-#endif
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(push,1)
+ throw *this;
+
#endif
+ }
+};
+
+// All boost exceptions are required to derive from std::exception,
+// to ensure compatibility with BOOST_NO_EXCEPTIONS.
+
+inline void throw_exception_assert_compatibility( std::exception const & ) {}
+
+// boost::throw_exception
+
+#if !defined( BOOST_NO_EXCEPTIONS )
+
+#if defined( BOOST_EXCEPTION_DISABLE )
+
+template<class E> BOOST_NORETURN void throw_exception( E const & e )
+{
+ throw_exception_assert_compatibility( e );
+ throw e;
+}
+
+template<class E> BOOST_NORETURN void throw_exception( E const & e, boost::source_location const & )
+{
+ throw_exception_assert_compatibility( e );
+ throw e;
+}
+
+#else // defined( BOOST_EXCEPTION_DISABLE )
+
+template<class E> BOOST_NORETURN void throw_exception( E const & e )
+{
+ throw_exception_assert_compatibility( e );
+ throw wrapexcept<E>( e );
+}
+
+template<class E> BOOST_NORETURN void throw_exception( E const & e, boost::source_location const & loc )
+{
+ throw_exception_assert_compatibility( e );
+ throw wrapexcept<E>( e, loc );
+}
+
+#endif // defined( BOOST_EXCEPTION_DISABLE )
+
+#endif // !defined( BOOST_NO_EXCEPTIONS )
+
+} // namespace boost
+
+// BOOST_THROW_EXCEPTION
+
+#define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x, BOOST_CURRENT_LOCATION)
namespace boost
{
-#ifdef BOOST_NO_EXCEPTIONS
-BOOST_NORETURN void throw_exception( std::exception const & e ); // user defined
+// throw_with_location
-#else
+namespace detail
+{
+
+struct BOOST_SYMBOL_VISIBLE throw_location
+{
+ boost::source_location location_;
+
+ explicit throw_location( boost::source_location const & loc ): location_( loc )
+ {
+ }
+};
+
+template<class E> class BOOST_SYMBOL_VISIBLE with_throw_location: public E, public throw_location
+{
+public:
+
+ with_throw_location( E const & e, boost::source_location const & loc ): E( e ), throw_location( loc )
+ {
+ }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+ with_throw_location( E && e, boost::source_location const & loc ): E( std::move( e ) ), throw_location( loc )
+ {
+ }
+
+#endif
+};
-inline void throw_exception_assert_compatibility( std::exception const & ) { }
+} // namespace detail
-template<class E> BOOST_NORETURN inline void throw_exception( E const & e )
+#if !defined(BOOST_NO_EXCEPTIONS)
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+
+template<class E> BOOST_NORETURN void throw_with_location( E && e, boost::source_location const & loc = BOOST_CURRENT_LOCATION )
{
- //All boost exceptions are required to derive from std::exception,
- //to ensure compatibility with BOOST_NO_EXCEPTIONS.
- throw_exception_assert_compatibility(e);
+ throw_exception_assert_compatibility( e );
+ throw detail::with_throw_location<typename std::decay<E>::type>( std::forward<E>( e ), loc );
+}
-#ifndef BOOST_EXCEPTION_DISABLE
- throw exception_detail::enable_both( e );
#else
- throw e;
+
+template<class E> BOOST_NORETURN void throw_with_location( E const & e, boost::source_location const & loc = BOOST_CURRENT_LOCATION )
+{
+ throw_exception_assert_compatibility( e );
+ throw detail::with_throw_location<E>( e, loc );
+}
+
#endif
+
+#else
+
+template<class E> BOOST_NORETURN void throw_with_location( E const & e, boost::source_location const & loc = BOOST_CURRENT_LOCATION )
+{
+ boost::throw_exception( e, loc );
}
#endif
-#if !defined( BOOST_EXCEPTION_DISABLE )
- namespace
- exception_detail
+// get_throw_location
+
+template<class E> boost::source_location get_throw_location( E const & e )
+{
+#if defined(BOOST_NO_RTTI)
+
+ (void)e;
+ return boost::source_location();
+
+#else
+
+ if( detail::throw_location const* pl = dynamic_cast< detail::throw_location const* >( &e ) )
+ {
+ return pl->location_;
+ }
+ else if( boost::exception const* px = dynamic_cast< boost::exception const* >( &e ) )
{
- template <class E>
- BOOST_NORETURN
- void
- throw_exception_( E const & x, char const * current_function, char const * file, int line )
- {
- boost::throw_exception(
- set_info(
- set_info(
- set_info(
- enable_error_info(x),
- throw_function(current_function)),
- throw_file(file)),
- throw_line(line)));
- }
+ return exception_detail::get_exception_throw_location( *px );
}
+ else
+ {
+ return boost::source_location();
+ }
+
#endif
+}
+
} // namespace boost
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(pop)
-#endif
-#endif
+#endif // #ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED
//
-// Copyright (c) 2012-2019 Antony Polukhin.
+// Copyright 2012-2022 Antony Polukhin.
//
// 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)
//
-// Copyright (c) 2013-2019 Antony Polukhin.
+// Copyright 2013-2022 Antony Polukhin.
//
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
//
-// Copyright (c) 2012-2019 Antony Polukhin.
+// Copyright 2012-2022 Antony Polukhin.
//
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
//
-// Copyright (c) 2013-2019 Antony Polukhin.
+// Copyright 2013-2022 Antony Polukhin.
//
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
//
-// Copyright (c) 2013-2019 Antony Polukhin.
+// Copyright 2013-2022 Antony Polukhin.
//
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
//
-// Copyright (c) 2013-2019 Antony Polukhin.
+// Copyright 2013-2022 Antony Polukhin.
//
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
//
-// Copyright (c) 2013-2019 Antony Polukhin.
+// Copyright 2013-2022 Antony Polukhin.
//
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
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
--- /dev/null
+
+// (C) Copyright 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_ALIGNMENT_OF_HPP_INCLUDED
+#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+#include <boost/type_traits/intrinsics.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable: 4121 4512) // alignment is sensitive to packing
+#endif
+#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x600)
+#pragma option push -Vx- -Ve-
+#endif
+
+namespace boost {
+
+template <typename T> struct alignment_of;
+
+// get the alignment of some arbitrary type:
+namespace detail {
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4324) // structure was padded due to __declspec(align())
+#endif
+template <typename T>
+struct alignment_of_hack
+{
+ char c;
+ T t;
+ alignment_of_hack();
+};
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+template <unsigned A, unsigned S>
+struct alignment_logic
+{
+ BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S);
+};
+
+
+template< typename T >
+struct alignment_of_impl
+{
+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
+ //
+ // With MSVC both the native __alignof operator
+ // and our own logic gets things wrong from time to time :-(
+ // Using a combination of the two seems to make the most of a bad job:
+ //
+ BOOST_STATIC_CONSTANT(std::size_t, value =
+ (::boost::detail::alignment_logic<
+ sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
+ __alignof(T)
+ >::value));
+#elif !defined(BOOST_ALIGNMENT_OF)
+ BOOST_STATIC_CONSTANT(std::size_t, value =
+ (::boost::detail::alignment_logic<
+ sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
+ sizeof(T)
+ >::value));
+#else
+ //
+ // We put this here, rather than in the definition of
+ // alignment_of below, because MSVC's __alignof doesn't
+ // always work in that context for some unexplained reason.
+ // (See type_with_alignment tests for test cases).
+ //
+ BOOST_STATIC_CONSTANT(std::size_t, value = BOOST_ALIGNMENT_OF(T));
+#endif
+};
+
+} // namespace detail
+
+template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};
+
+// references have to be treated specially, assume
+// that a reference is just a special pointer:
+template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
+
+#ifdef BOOST_BORLANDC
+// long double gives an incorrect value of 10 (!)
+// unless we do this...
+struct long_double_wrapper{ long double ld; };
+template<> struct alignment_of<long double> : public alignment_of<long_double_wrapper>{};
+#endif
+
+// void has to be treated specially:
+template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
+template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
+template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};
+#endif
+
+} // namespace boost
+
+#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x600)
+#pragma option pop
+#endif
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
+
--- /dev/null
+/*
+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
// 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 /**/
# 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)) \
// 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
//
#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_ASCCURATE_IS_FUNCTION
+# define BOOST_TT_HAS_ACCURATE_IS_FUNCTION
#endif
#if defined(_MSVC_LANG) && (_MSVC_LANG >= 201703)
#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
namespace boost {
-#if !defined( __CODEGEARC__ )
+#if !defined( BOOST_CODEGEARC )
namespace detail {
} // namespace detail
-#endif // !defined( __CODEGEARC__ )
+#endif // !defined( BOOST_CODEGEARC )
-#if defined( __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> {};
#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)
-#ifdef __CLR_VER
+
+#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 __clrcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+
+#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 __clrcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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)
-#ifdef __CLR_VER
+
+#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 __clrcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
+#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 __clrcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
#endif
-#ifndef _M_AMD64
+#ifdef _MANAGED
template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
- struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-#ifndef __CLR_VER
+ 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
-#endif
-#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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)
template <class R >
struct is_function_ptr_helper<R(*)(...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R >
struct is_function_ptr_helper<R(*)()noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T0>
struct is_function_ptr_helper<R(*)(T0 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0>
struct is_function_ptr_helper<R(*)(T0)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T0, class T1>
struct is_function_ptr_helper<R(*)(T0, T1 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1>
struct is_function_ptr_helper<R(*)(T0, T1)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T0, class T1, class T2>
struct is_function_ptr_helper<R(*)(T0, T1, T2 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1, class T2>
struct is_function_ptr_helper<R(*)(T0, T1, T2)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T0, class T1, class T2, class T3>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1, class T2, class T3>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T0, class T1, class T2, class T3, class T4>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1, class T2, class T3, class T4>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<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 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<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)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#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>
struct is_function_ptr_helper<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 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
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>
struct is_function_ptr_helper<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)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T)>
struct is_function_ptr_helper<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
@#endif
-@#if __cpp_noexcept_function_type
+@#ifdef __cpp_noexcept_function_type
template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, class T)>
struct is_function_ptr_helper<R(*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, T))noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R >
yes_type is_function_ptr_tester(R(__stdcall*)());
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T0 >
yes_type is_function_ptr_tester(R(__stdcall*)(T0));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T0, class T1 >
yes_type is_function_ptr_tester(R(__stdcall*)(T0, T1));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
#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));
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
@#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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+@#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
struct is_mem_fun_pointer_impl<R(T::*)(...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)()noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, 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>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(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> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, 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>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(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> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, 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>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
struct is_mem_fun_pointer_impl<R(T::*)(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> { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
#endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, 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>
struct is_mem_fun_pointer_impl<R(T::*)(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)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@#endif
@#endif
-@#if __cpp_noexcept_function_type
+@#ifdef __cpp_noexcept_function_type
template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, class T)>
struct is_mem_fun_pointer_impl<R(T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, T))noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
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);
-#if (_MSC_VER >= 1800) && !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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(__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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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 >
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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+@#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)));
#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(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
+#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
namespace boost {
-#if defined( __CODEGEARC__ )
+#if defined( BOOST_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)
+#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>{};
namespace detail {
-#ifndef __BORLANDC__
+#ifndef BOOST_BORLANDC
template <bool>
struct is_mem_fun_pointer_select
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)
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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)
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)
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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:
-#ifdef __CLR_VER
- 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 {};
-
-#endif
-#ifndef _M_AMD64
+#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 {};
-#ifndef __CLR_VER
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 {};
+ 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(__cdecl C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
+ 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(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64))
+#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
--- /dev/null
+/*
+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
#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)) )\
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
-#if defined(BOOST_CLANG) && defined(__has_feature) && !defined(__CUDACC__)
+#if defined(BOOST_CLANG) && defined(__has_feature) && defined(__has_builtin) && (!(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.
# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty)
# define BOOST_IS_EMPTY(T) __is_empty(T)
# endif
-# if __has_feature(has_trivial_constructor)
+# if __has_builtin(__is_trivially_constructible)
+# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __is_trivially_constructible(T)
+# elif __has_feature(has_trivial_constructor)
# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
# endif
-# if __has_feature(has_trivial_copy)
+# if __has_builtin(__is_trivially_copyable)
+# define BOOST_HAS_TRIVIAL_COPY(T) (__is_trivially_copyable(T) && !is_reference<T>::value)
+# elif __has_feature(has_trivial_copy)
# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value)
# endif
-# if __has_feature(has_trivial_assign)
+# if __has_builtin(__is_trivially_assignable)
+# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__is_trivially_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
+# elif __has_feature(has_trivial_assign)
# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
# endif
-# if __has_feature(has_trivial_destructor)
+# if __has_builtin(__is_trivially_destructible)
+# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__is_trivially_destructible(T) && is_destructible<T>::value)
+# elif __has_feature(has_trivial_destructor)
# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) && is_destructible<T>::value)
# endif
-# if __has_feature(has_nothrow_constructor)
+# if __has_builtin(__is_nothrow_constructible)
+# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__is_nothrow_constructible(T) && is_default_constructible<T>::value)
+# elif __has_feature(has_nothrow_constructor)
# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) && is_default_constructible<T>::value)
# endif
-# if __has_feature(has_nothrow_copy)
+# if __has_builtin(__is_nothrow_constructible)
+# define BOOST_HAS_NOTHROW_COPY(T) (__is_nothrow_constructible(T, const T&) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
+# elif __has_feature(has_nothrow_copy)
# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
# endif
-# if __has_feature(has_nothrow_assign)
+# if __has_builtin(__is_nothrow_assignable)
+# define BOOST_HAS_NOTHROW_ASSIGN(T) (__is_nothrow_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
+# elif __has_feature(has_nothrow_assign)
# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
# endif
# if __has_feature(has_virtual_destructor)
# 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>
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 {};
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{};
#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/config/workaround.hpp>
+#include <cstddef>
/*
* CAUTION:
namespace detail{
- template <unsigned N>
+ template <std::size_t N>
struct ok_tag { double d; char c[N]; };
template <class T>
namespace boost {
-#if defined( __CODEGEARC__ )
+#if defined( BOOST_CODEGEARC )
template <class T>
struct is_const : public integral_constant<bool, __is_const(T)> {};
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
#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 (...)
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
{
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__)
namespace boost {
#ifndef BOOST_IS_ENUM
-#if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551))
+#if !(defined(BOOST_BORLANDC) && (BOOST_BORLANDC <= 0x551))
namespace detail {
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));
#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;
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:
#include <boost/type_traits/detail/config.hpp>
#include <boost/config/workaround.hpp>
-#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION
+#ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION
#include <boost/type_traits/detail/is_function_cxx_11.hpp>
namespace boost {
-#if defined( __CODEGEARC__ )
+#if defined( BOOST_CODEGEARC )
template <class T>
struct is_integral : public integral_constant<bool, __is_integral(T)> {};
#else
// 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
namespace boost {
-#if defined( __CODEGEARC__ )
+#if defined( BOOST_CODEGEARC )
template <class T> struct is_lvalue_reference : public integral_constant<bool, __is_reference(T)>{};
#else
#include <boost/type_traits/detail/config.hpp>
-#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION
+#ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION
#include <boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp>
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>{};
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{};
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{};
namespace boost {
-#if !defined( __CODEGEARC__ )
+#if !defined( BOOST_CODEGEARC )
#if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1310) && \
!(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) &&\
#endif
-#else //defined( __CODEGEARC__ )
+#else //defined( BOOST_CODEGEARC )
template <class T> struct is_signed : public integral_constant<bool, __is_signed(T)>{};
#endif
namespace boost {
-#if !defined( __CODEGEARC__ )
+#if !defined( BOOST_CODEGEARC )
#if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1310) &&\
!(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) &&\
#endif
-#else // defined( __CODEGEARC__ )
+#else // defined( BOOST_CODEGEARC )
template <class T> struct is_unsigned : public integral_constant<bool, __is_unsigned(T)> {};
#endif
namespace boost {
-#if defined( __CODEGEARC__ )
+#if defined( BOOST_CODEGEARC )
template <class T>
struct is_volatile : public integral_constant<bool, __is_volatile(T)> {};
--- /dev/null
+
+// (C) Copyright John Maddock 2007.
+// 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_MAKE_UNSIGNED_HPP_INCLUDED
+#define BOOST_TT_MAKE_UNSIGNED_HPP_INCLUDED
+
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_volatile.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost {
+
+template <class T>
+struct make_unsigned
+{
+private:
+ BOOST_STATIC_ASSERT_MSG((::boost::is_integral<T>::value || ::boost::is_enum<T>::value), "The template argument to make_unsigned must be an integer or enum type.");
+ BOOST_STATIC_ASSERT_MSG((! ::boost::is_same<typename remove_cv<T>::type, bool>::value), "The template argument to make_unsigned must not be the type bool");
+
+ typedef typename remove_cv<T>::type t_no_cv;
+ typedef typename conditional<
+ (::boost::is_unsigned<T>::value && ::boost::is_integral<T>::value
+ && ! ::boost::is_same<t_no_cv, char>::value
+ && ! ::boost::is_same<t_no_cv, wchar_t>::value
+ && ! ::boost::is_same<t_no_cv, bool>::value),
+ T,
+ typename conditional<
+ (::boost::is_integral<T>::value
+ && ! ::boost::is_same<t_no_cv, char>::value
+ && ! ::boost::is_same<t_no_cv, wchar_t>::value
+ && ! ::boost::is_same<t_no_cv, bool>::value),
+ typename conditional<
+ is_same<t_no_cv, signed char>::value,
+ unsigned char,
+ typename conditional<
+ is_same<t_no_cv, short>::value,
+ unsigned short,
+ typename conditional<
+ is_same<t_no_cv, int>::value,
+ unsigned int,
+ typename conditional<
+ is_same<t_no_cv, long>::value,
+ unsigned long,
+#if defined(BOOST_HAS_LONG_LONG)
+#ifdef BOOST_HAS_INT128
+ typename conditional<
+ sizeof(t_no_cv) == sizeof(boost::ulong_long_type),
+ boost::ulong_long_type,
+ boost::uint128_type
+ >::type
+#else
+ boost::ulong_long_type
+#endif
+#elif defined(BOOST_HAS_MS_INT64)
+ unsigned __int64
+#else
+ unsigned long
+#endif
+ >::type
+ >::type
+ >::type
+ >::type,
+ // Not a regular integer type:
+ typename conditional<
+ sizeof(t_no_cv) == sizeof(unsigned char),
+ unsigned char,
+ typename conditional<
+ sizeof(t_no_cv) == sizeof(unsigned short),
+ unsigned short,
+ typename conditional<
+ sizeof(t_no_cv) == sizeof(unsigned int),
+ unsigned int,
+ typename conditional<
+ sizeof(t_no_cv) == sizeof(unsigned long),
+ unsigned long,
+#if defined(BOOST_HAS_LONG_LONG)
+#ifdef BOOST_HAS_INT128
+ typename conditional<
+ sizeof(t_no_cv) == sizeof(boost::ulong_long_type),
+ boost::ulong_long_type,
+ boost::uint128_type
+ >::type
+#else
+ boost::ulong_long_type
+#endif
+#elif defined(BOOST_HAS_MS_INT64)
+ unsigned __int64
+#else
+ unsigned long
+#endif
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type base_integer_type;
+
+ // Add back any const qualifier:
+ typedef typename conditional<
+ is_const<T>::value,
+ typename add_const<base_integer_type>::type,
+ base_integer_type
+ >::type const_base_integer_type;
+public:
+ // Add back any volatile qualifier:
+ typedef typename conditional<
+ is_volatile<T>::value,
+ typename add_volatile<const_base_integer_type>::type,
+ const_base_integer_type
+ >::type type;
+};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+ template <class T> using make_unsigned_t = typename make_unsigned<T>::type;
+
+#endif
+
+} // namespace boost
+
+#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
+
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[]; };
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; };
// BOOST_VERSION / 100 % 1000 is the minor version
// BOOST_VERSION / 100000 is the major version
-#define BOOST_VERSION 107200
+#define BOOST_VERSION 108100
//
// BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
// number, y is the minor version number, and z is the patch level if not 0.
// This is used by <config/auto_link.hpp> to select which library version to link to.
-#define BOOST_LIB_VERSION "1_72"
+#define BOOST_LIB_VERSION "1_81"
#endif
projects / features.git / commitdiff