From 2712c9807e32a6d7b460180f1f10e6226ab43ae4 Mon Sep 17 00:00:00 2001 From: Jean-Marc Lasgouttes Date: Thu, 2 Feb 2023 10:08:19 +0100 Subject: [PATCH] Update to boost 1.81 --- 3rdparty/boost/boost/any.hpp | 64 +- 3rdparty/boost/boost/any/bad_any_cast.hpp | 43 + 3rdparty/boost/boost/any/fwd.hpp | 40 + 3rdparty/boost/boost/array.hpp | 5 +- .../boost/boost/assert/source_location.hpp | 189 +++ 3rdparty/boost/boost/config/abi_prefix.hpp | 2 +- 3rdparty/boost/boost/config/abi_suffix.hpp | 4 +- 3rdparty/boost/boost/config/assert_cxx03.hpp | 211 +++ 3rdparty/boost/boost/config/assert_cxx11.hpp | 209 +++ 3rdparty/boost/boost/config/assert_cxx14.hpp | 47 + 3rdparty/boost/boost/config/assert_cxx17.hpp | 62 + 3rdparty/boost/boost/config/assert_cxx20.hpp | 59 + 3rdparty/boost/boost/config/assert_cxx98.hpp | 23 + 3rdparty/boost/boost/config/auto_link.hpp | 84 +- .../boost/boost/config/compiler/borland.hpp | 5 +- .../boost/boost/config/compiler/clang.hpp | 20 +- .../boost/config/compiler/clang_version.hpp | 83 ++ .../boost/boost/config/compiler/codegear.hpp | 165 ++- .../boost/config/compiler/common_edg.hpp | 44 +- 3rdparty/boost/boost/config/compiler/cray.hpp | 5 + .../boost/config/compiler/digitalmars.hpp | 2 + 3rdparty/boost/boost/config/compiler/gcc.hpp | 33 +- .../boost/boost/config/compiler/gcc_xml.hpp | 2 + .../boost/boost/config/compiler/hp_acc.hpp | 1 + .../boost/boost/config/compiler/intel.hpp | 7 + .../boost/config/compiler/metrowerks.hpp | 2 + 3rdparty/boost/boost/config/compiler/mpw.hpp | 2 + 3rdparty/boost/boost/config/compiler/nvcc.hpp | 3 + .../boost/boost/config/compiler/pathscale.hpp | 2 + .../boost/boost/config/compiler/sunpro_cc.hpp | 8 + .../boost/boost/config/compiler/vacpp.hpp | 2 + .../boost/boost/config/compiler/visualc.hpp | 23 + .../boost/boost/config/compiler/xlcpp.hpp | 10 + .../boost/boost/config/compiler/xlcpp_zos.hpp | 2 + .../boost/config/detail/cxx_composite.hpp | 203 +++ .../config/detail/select_compiler_config.hpp | 2 +- .../config/detail/select_platform_config.hpp | 5 + .../config/detail/select_stdlib_config.hpp | 15 +- 3rdparty/boost/boost/config/detail/suffix.hpp | 202 ++- .../boost/boost/config/header_deprecated.hpp | 2 +- 3rdparty/boost/boost/config/platform/bsd.hpp | 13 +- 3rdparty/boost/boost/config/platform/wasm.hpp | 23 + .../boost/boost/config/requires_threads.hpp | 2 +- .../boost/boost/config/stdlib/dinkumware.hpp | 46 +- 3rdparty/boost/boost/config/stdlib/libcpp.hpp | 37 +- .../boost/boost/config/stdlib/libstdcpp3.hpp | 122 +- .../boost/boost/config/stdlib/roguewave.hpp | 2 +- .../boost/boost/config/stdlib/stlport.hpp | 10 +- 3rdparty/boost/boost/config/workaround.hpp | 26 + .../container_hash/detail/float_functions.hpp | 336 ----- .../container_hash/detail/hash_float.hpp | 271 ---- .../boost/container_hash/detail/hash_mix.hpp | 113 ++ .../container_hash/detail/hash_range.hpp | 173 +++ .../container_hash/detail/hash_tuple.hpp | 133 ++ .../boost/container_hash/detail/limits.hpp | 62 - .../boost/boost/container_hash/extensions.hpp | 414 ------ 3rdparty/boost/boost/container_hash/hash.hpp | 1175 +++++++-------- .../boost/boost/container_hash/hash_fwd.hpp | 48 +- .../container_hash/is_contiguous_range.hpp | 91 ++ .../container_hash/is_described_class.hpp | 38 + .../boost/boost/container_hash/is_range.hpp | 73 + .../container_hash/is_unordered_range.hpp | 39 + 3rdparty/boost/boost/core/addressof.hpp | 4 +- 3rdparty/boost/boost/core/swap.hpp | 9 +- 3rdparty/boost/boost/crc.hpp | 6 +- 3rdparty/boost/boost/cstdint.hpp | 4 +- 3rdparty/boost/boost/describe/bases.hpp | 50 + .../boost/boost/describe/detail/config.hpp | 40 + .../boost/boost/describe/detail/cx_streq.hpp | 30 + .../boost/boost/describe/detail/void_t.hpp | 32 + 3rdparty/boost/boost/describe/members.hpp | 159 ++ 3rdparty/boost/boost/describe/modifiers.hpp | 33 + 3rdparty/boost/boost/detail/container_fwd.hpp | 157 -- 3rdparty/boost/boost/detail/iterator.hpp | 39 - 3rdparty/boost/boost/detail/workaround.hpp | 6 +- 3rdparty/boost/boost/exception/exception.hpp | 147 +- 3rdparty/boost/boost/integer.hpp | 8 +- 3rdparty/boost/boost/integer/static_log2.hpp | 127 -- 3rdparty/boost/boost/integer_fwd.hpp | 4 +- 3rdparty/boost/boost/integer_traits.hpp | 6 +- 3rdparty/boost/boost/mp11/algorithm.hpp | 1306 +++++++++++++++++ 3rdparty/boost/boost/mp11/bind.hpp | 111 ++ 3rdparty/boost/boost/mp11/detail/config.hpp | 138 ++ .../boost/boost/mp11/detail/mp_append.hpp | 185 +++ .../boost/boost/mp11/detail/mp_copy_if.hpp | 48 + 3rdparty/boost/boost/mp11/detail/mp_count.hpp | 147 ++ 3rdparty/boost/boost/mp11/detail/mp_fold.hpp | 62 + 3rdparty/boost/boost/mp11/detail/mp_front.hpp | 38 + .../boost/boost/mp11/detail/mp_is_list.hpp | 39 + 3rdparty/boost/boost/mp11/detail/mp_list.hpp | 24 + .../boost/boost/mp11/detail/mp_map_find.hpp | 87 ++ .../boost/mp11/detail/mp_min_element.hpp | 51 + 3rdparty/boost/boost/mp11/detail/mp_plus.hpp | 81 + .../boost/boost/mp11/detail/mp_remove_if.hpp | 48 + .../boost/boost/mp11/detail/mp_rename.hpp | 41 + 3rdparty/boost/boost/mp11/detail/mp_void.hpp | 32 + .../boost/boost/mp11/detail/mp_with_index.hpp | 385 +++++ 3rdparty/boost/boost/mp11/function.hpp | 222 +++ .../boost/boost/mp11/integer_sequence.hpp | 112 ++ 3rdparty/boost/boost/mp11/integral.hpp | 41 + 3rdparty/boost/boost/mp11/list.hpp | 304 ++++ 3rdparty/boost/boost/mp11/set.hpp | 188 +++ 3rdparty/boost/boost/mp11/utility.hpp | 263 ++++ 3rdparty/boost/boost/mp11/version.hpp | 16 + .../boost/preprocessor/config/config.hpp | 49 +- 3rdparty/boost/boost/static_assert.hpp | 5 +- 3rdparty/boost/boost/swap.hpp | 17 - 3rdparty/boost/boost/throw_exception.hpp | 311 +++- 3rdparty/boost/boost/type_index.hpp | 2 +- .../boost/type_index/ctti_type_index.hpp | 2 +- .../detail/compile_time_type_info.hpp | 2 +- .../type_index/detail/ctti_register_class.hpp | 2 +- .../type_index/detail/stl_register_class.hpp | 2 +- .../boost/boost/type_index/stl_type_index.hpp | 2 +- .../boost/type_index/type_index_facade.hpp | 2 +- .../boost/boost/type_traits/add_pointer.hpp | 2 +- .../boost/boost/type_traits/alignment_of.hpp | 119 ++ .../boost/boost/type_traits/conjunction.hpp | 40 + .../boost/boost/type_traits/detail/config.hpp | 11 +- .../type_traits/detail/is_function_cxx_03.hpp | 6 +- .../type_traits/detail/is_function_cxx_11.hpp | 463 +++--- .../detail/is_function_ptr_helper.hpp | 54 +- .../detail/is_function_ptr_tester.hpp | 54 +- .../detail/is_mem_fun_pointer_impl.hpp | 54 +- .../detail/is_mem_fun_pointer_tester.hpp | 54 +- .../is_member_function_pointer_cxx_03.hpp | 8 +- .../is_member_function_pointer_cxx_11.hpp | 507 ++++--- .../boost/boost/type_traits/enable_if.hpp | 37 + .../boost/type_traits/integral_constant.hpp | 2 +- .../boost/boost/type_traits/intrinsics.hpp | 32 +- 3rdparty/boost/boost/type_traits/is_array.hpp | 4 +- .../boost/boost/type_traits/is_complete.hpp | 3 +- 3rdparty/boost/boost/type_traits/is_const.hpp | 2 +- .../boost/type_traits/is_convertible.hpp | 8 +- 3rdparty/boost/boost/type_traits/is_enum.hpp | 8 +- .../boost/boost/type_traits/is_function.hpp | 2 +- .../boost/boost/type_traits/is_integral.hpp | 6 +- .../boost/type_traits/is_lvalue_reference.hpp | 2 +- .../is_member_function_pointer.hpp | 2 +- .../boost/type_traits/is_member_pointer.hpp | 2 +- .../boost/boost/type_traits/is_pointer.hpp | 2 +- 3rdparty/boost/boost/type_traits/is_same.hpp | 2 +- .../boost/boost/type_traits/is_signed.hpp | 4 +- .../boost/boost/type_traits/is_unsigned.hpp | 4 +- .../boost/boost/type_traits/is_volatile.hpp | 2 +- .../boost/boost/type_traits/make_unsigned.hpp | 136 ++ .../boost/boost/type_traits/remove_cv.hpp | 2 +- .../boost/boost/type_traits/remove_extent.hpp | 2 +- 3rdparty/boost/boost/version.hpp | 4 +- 149 files changed, 9012 insertions(+), 2993 deletions(-) create mode 100644 3rdparty/boost/boost/any/bad_any_cast.hpp create mode 100644 3rdparty/boost/boost/any/fwd.hpp create mode 100644 3rdparty/boost/boost/assert/source_location.hpp create mode 100644 3rdparty/boost/boost/config/assert_cxx03.hpp create mode 100644 3rdparty/boost/boost/config/assert_cxx11.hpp create mode 100644 3rdparty/boost/boost/config/assert_cxx14.hpp create mode 100644 3rdparty/boost/boost/config/assert_cxx17.hpp create mode 100644 3rdparty/boost/boost/config/assert_cxx20.hpp create mode 100644 3rdparty/boost/boost/config/assert_cxx98.hpp create mode 100644 3rdparty/boost/boost/config/compiler/clang_version.hpp create mode 100644 3rdparty/boost/boost/config/detail/cxx_composite.hpp create mode 100644 3rdparty/boost/boost/config/platform/wasm.hpp delete mode 100644 3rdparty/boost/boost/container_hash/detail/float_functions.hpp delete mode 100644 3rdparty/boost/boost/container_hash/detail/hash_float.hpp create mode 100644 3rdparty/boost/boost/container_hash/detail/hash_mix.hpp create mode 100644 3rdparty/boost/boost/container_hash/detail/hash_range.hpp create mode 100644 3rdparty/boost/boost/container_hash/detail/hash_tuple.hpp delete mode 100644 3rdparty/boost/boost/container_hash/detail/limits.hpp delete mode 100644 3rdparty/boost/boost/container_hash/extensions.hpp create mode 100644 3rdparty/boost/boost/container_hash/is_contiguous_range.hpp create mode 100644 3rdparty/boost/boost/container_hash/is_described_class.hpp create mode 100644 3rdparty/boost/boost/container_hash/is_range.hpp create mode 100644 3rdparty/boost/boost/container_hash/is_unordered_range.hpp create mode 100644 3rdparty/boost/boost/describe/bases.hpp create mode 100644 3rdparty/boost/boost/describe/detail/config.hpp create mode 100644 3rdparty/boost/boost/describe/detail/cx_streq.hpp create mode 100644 3rdparty/boost/boost/describe/detail/void_t.hpp create mode 100644 3rdparty/boost/boost/describe/members.hpp create mode 100644 3rdparty/boost/boost/describe/modifiers.hpp delete mode 100644 3rdparty/boost/boost/detail/container_fwd.hpp delete mode 100644 3rdparty/boost/boost/detail/iterator.hpp delete mode 100644 3rdparty/boost/boost/integer/static_log2.hpp create mode 100644 3rdparty/boost/boost/mp11/algorithm.hpp create mode 100644 3rdparty/boost/boost/mp11/bind.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/config.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_append.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_copy_if.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_count.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_fold.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_front.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_is_list.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_list.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_map_find.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_min_element.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_plus.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_remove_if.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_rename.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_void.hpp create mode 100644 3rdparty/boost/boost/mp11/detail/mp_with_index.hpp create mode 100644 3rdparty/boost/boost/mp11/function.hpp create mode 100644 3rdparty/boost/boost/mp11/integer_sequence.hpp create mode 100644 3rdparty/boost/boost/mp11/integral.hpp create mode 100644 3rdparty/boost/boost/mp11/list.hpp create mode 100644 3rdparty/boost/boost/mp11/set.hpp create mode 100644 3rdparty/boost/boost/mp11/utility.hpp create mode 100644 3rdparty/boost/boost/mp11/version.hpp delete mode 100644 3rdparty/boost/boost/swap.hpp create mode 100644 3rdparty/boost/boost/type_traits/alignment_of.hpp create mode 100644 3rdparty/boost/boost/type_traits/conjunction.hpp create mode 100644 3rdparty/boost/boost/type_traits/enable_if.hpp create mode 100644 3rdparty/boost/boost/type_traits/make_unsigned.hpp diff --git a/3rdparty/boost/boost/any.hpp b/3rdparty/boost/boost/any.hpp index 36dd11fecc..9d2e921416 100644 --- a/3rdparty/boost/boost/any.hpp +++ b/3rdparty/boost/boost/any.hpp @@ -3,20 +3,20 @@ #ifndef BOOST_ANY_INCLUDED #define BOOST_ANY_INCLUDED -#if defined(_MSC_VER) +#include +#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 +// when: July 2001, April 2013 - 2020 -#include - -#include +#include +#include #include #include #include @@ -29,7 +29,6 @@ #include #include #include -#include #include namespace boost @@ -49,6 +48,10 @@ namespace boost BOOST_DEDUCED_TYPENAME remove_cv::type>::type >(value)) { + BOOST_STATIC_ASSERT_MSG( + !anys::detail::is_basic_any::value, + "boost::any shall not be constructed from boost::anys::basic_any" + ); } any(const any & other) @@ -71,6 +74,10 @@ namespace boost , typename boost::disable_if >::type* = 0) // disable if value has type `const ValueType&&` : content(new holder< typename decay::type >(static_cast(value))) { + BOOST_STATIC_ASSERT_MSG( + !anys::detail::is_basic_any::type>::value, + "boost::any shall not be constructed from boost::anys::basic_any" + ); } #endif @@ -83,7 +90,9 @@ namespace boost any & swap(any & rhs) BOOST_NOEXCEPT { - std::swap(content, rhs.content); + placeholder* tmp = content; + content = rhs.content; + rhs.content = tmp; return *this; } @@ -92,6 +101,10 @@ namespace boost template any & operator=(const ValueType & rhs) { + BOOST_STATIC_ASSERT_MSG( + !anys::detail::is_basic_any::value, + "boost::anys::basic_any shall not be assigned into boost::any" + ); any(rhs).swap(*this); return *this; } @@ -102,7 +115,7 @@ namespace boost return *this; } -#else +#else any & operator=(const any& rhs) { any(rhs).swap(*this); @@ -121,6 +134,10 @@ namespace boost template any & operator=(ValueType&& rhs) { + BOOST_STATIC_ASSERT_MSG( + !anys::detail::is_basic_any::type>::value, + "boost::anys::basic_any shall not be assigned into boost::any" + ); any(static_cast(rhs)).swap(*this); return *this; } @@ -187,12 +204,12 @@ namespace boost #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().type_info(); } - virtual placeholder * clone() const + placeholder * clone() const BOOST_OVERRIDE { return new holder(held); } @@ -224,27 +241,12 @@ namespace boost 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 ValueType * any_cast(any * operand) BOOST_NOEXCEPT { @@ -271,9 +273,9 @@ namespace boost 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(*result);` + // `static_cast(*result);` // which is equal to `std::string(*result);` typedef BOOST_DEDUCED_TYPENAME boost::conditional< boost::is_reference::value, @@ -305,7 +307,7 @@ namespace boost BOOST_STATIC_ASSERT_MSG( boost::is_rvalue_reference::value /*true if ValueType is rvalue or just a value*/ || boost::is_const< typename boost::remove_reference::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(operand); } @@ -333,7 +335,7 @@ namespace boost } // 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 diff --git a/3rdparty/boost/boost/any/bad_any_cast.hpp b/3rdparty/boost/boost/any/bad_any_cast.hpp new file mode 100644 index 0000000000..bba142da50 --- /dev/null +++ b/3rdparty/boost/boost/any/bad_any_cast.hpp @@ -0,0 +1,43 @@ +// 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 +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + +#ifndef BOOST_NO_RTTI +#include +#endif + +#include + +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 diff --git a/3rdparty/boost/boost/any/fwd.hpp b/3rdparty/boost/boost/any/fwd.hpp new file mode 100644 index 0000000000..6905b26440 --- /dev/null +++ b/3rdparty/boost/boost/any/fwd.hpp @@ -0,0 +1,40 @@ +// 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 +#ifdef BOOST_HAS_PRAGMA_ONCE +# pragma once +#endif + + #include + +namespace boost { + +class any; + +namespace anys { + +template::value> +class basic_any; + +namespace detail { + template + struct is_basic_any: public false_type {}; + + + template + struct is_basic_any > : public true_type {}; +} // namespace detail + +} // namespace anys + +} // namespace boost + +#endif // #ifndef BOOST_ANY_ANYS_FWD_HPP diff --git a/3rdparty/boost/boost/array.hpp b/3rdparty/boost/boost/array.hpp index 99dc2c6ded..f047063d90 100644 --- a/3rdparty/boost/boost/array.hpp +++ b/3rdparty/boost/boost/array.hpp @@ -41,13 +41,12 @@ #endif #include +#include #include #include +#include #include -#include -// Handles broken standard libraries better than -#include #include #include diff --git a/3rdparty/boost/boost/assert/source_location.hpp b/3rdparty/boost/boost/assert/source_location.hpp new file mode 100644 index 0000000000..0d76858288 --- /dev/null +++ b/3rdparty/boost/boost/assert/source_location.hpp @@ -0,0 +1,189 @@ +#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 +#include +#include +#include +#include +#include +#include +#include + +#if defined(__cpp_lib_source_location) && __cpp_lib_source_location >= 201907L +# include +#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 std::basic_ostream & operator<<( std::basic_ostream & 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 diff --git a/3rdparty/boost/boost/config/abi_prefix.hpp b/3rdparty/boost/boost/config/abi_prefix.hpp index 3b1347492c..bcdc26d9dc 100644 --- a/3rdparty/boost/boost/config/abi_prefix.hpp +++ b/3rdparty/boost/boost/config/abi_prefix.hpp @@ -19,7 +19,7 @@ # include BOOST_ABI_PREFIX #endif -#if defined( __BORLANDC__ ) +#if defined( BOOST_BORLANDC ) #pragma nopushoptwarn #endif diff --git a/3rdparty/boost/boost/config/abi_suffix.hpp b/3rdparty/boost/boost/config/abi_suffix.hpp index 939161662a..a1eb78db90 100644 --- a/3rdparty/boost/boost/config/abi_suffix.hpp +++ b/3rdparty/boost/boost/config/abi_suffix.hpp @@ -20,8 +20,6 @@ # include BOOST_ABI_SUFFIX #endif -#if defined( __BORLANDC__ ) +#if defined( BOOST_BORLANDC ) #pragma nopushoptwarn #endif - - diff --git a/3rdparty/boost/boost/config/assert_cxx03.hpp b/3rdparty/boost/boost/config/assert_cxx03.hpp new file mode 100644 index 0000000000..03360a9322 --- /dev/null +++ b/3rdparty/boost/boost/config/assert_cxx03.hpp @@ -0,0 +1,211 @@ +// 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 + +#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 diff --git a/3rdparty/boost/boost/config/assert_cxx11.hpp b/3rdparty/boost/boost/config/assert_cxx11.hpp new file mode 100644 index 0000000000..b029a27485 --- /dev/null +++ b/3rdparty/boost/boost/config/assert_cxx11.hpp @@ -0,0 +1,209 @@ +// 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 +#include + +#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 diff --git a/3rdparty/boost/boost/config/assert_cxx14.hpp b/3rdparty/boost/boost/config/assert_cxx14.hpp new file mode 100644 index 0000000000..1d3132a1d3 --- /dev/null +++ b/3rdparty/boost/boost/config/assert_cxx14.hpp @@ -0,0 +1,47 @@ +// 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 +#include + +#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 diff --git a/3rdparty/boost/boost/config/assert_cxx17.hpp b/3rdparty/boost/boost/config/assert_cxx17.hpp new file mode 100644 index 0000000000..cd41be61b4 --- /dev/null +++ b/3rdparty/boost/boost/config/assert_cxx17.hpp @@ -0,0 +1,62 @@ +// 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 +#include + +#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 diff --git a/3rdparty/boost/boost/config/assert_cxx20.hpp b/3rdparty/boost/boost/config/assert_cxx20.hpp new file mode 100644 index 0000000000..c148277856 --- /dev/null +++ b/3rdparty/boost/boost/config/assert_cxx20.hpp @@ -0,0 +1,59 @@ +// 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 +#include + +#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 diff --git a/3rdparty/boost/boost/config/assert_cxx98.hpp b/3rdparty/boost/boost/config/assert_cxx98.hpp new file mode 100644 index 0000000000..aa745d43f9 --- /dev/null +++ b/3rdparty/boost/boost/config/assert_cxx98.hpp @@ -0,0 +1,23 @@ +// 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 +#include + +#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 diff --git a/3rdparty/boost/boost/config/auto_link.hpp b/3rdparty/boost/boost/config/auto_link.hpp index e74f3c10e9..64dee1ef16 100644 --- a/3rdparty/boost/boost/config/auto_link.hpp +++ b/3rdparty/boost/boost/config/auto_link.hpp @@ -51,6 +51,7 @@ BOOST_LIB_PREFIX + BOOST_LIB_ARCH_AND_MODEL_OPT "-" + BOOST_LIB_VERSION + + BOOST_LIB_SUFFIX These are defined as: @@ -78,6 +79,7 @@ BOOST_LIB_ARCH_AND_MODEL_OPT: The architecture and address model 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. ***************************************************************************/ @@ -97,7 +99,8 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. // 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)) @@ -179,12 +182,22 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. // 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" @@ -334,12 +347,32 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. # 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 // @@ -357,7 +390,7 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. # 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 @@ -415,30 +448,36 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. && 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_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) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT BOOST_LIB_SUFFIX) # endif #elif defined(BOOST_AUTO_LINK_SYSTEM) -# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib") +# 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_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib") -# endif -#elif defined(BOOST_AUTO_LINK_NOMANGLE) -# pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib") -# 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 @@ -481,5 +520,6 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. #if defined(BOOST_DYN_LINK) # undef BOOST_DYN_LINK #endif - - +#if defined(BOOST_LIB_SUFFIX) +# undef BOOST_LIB_SUFFIX +#endif diff --git a/3rdparty/boost/boost/config/compiler/borland.hpp b/3rdparty/boost/boost/config/compiler/borland.hpp index beec94621f..c5113b7151 100644 --- a/3rdparty/boost/boost/config/compiler/borland.hpp +++ b/3rdparty/boost/boost/config/compiler/borland.hpp @@ -198,7 +198,9 @@ #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) @@ -332,4 +334,5 @@ // (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__) diff --git a/3rdparty/boost/boost/config/compiler/clang.hpp b/3rdparty/boost/boost/config/compiler/clang.hpp index 52b23d9d02..cb08d27f26 100644 --- a/3rdparty/boost/boost/config/compiler/clang.hpp +++ b/3rdparty/boost/boost/config/compiler/clang.hpp @@ -250,6 +250,11 @@ #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__)) @@ -320,11 +325,18 @@ // 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: @@ -346,3 +358,5 @@ // Macro used to identify the Clang compiler. #define BOOST_CLANG 1 +// BOOST_CLANG_VERSION +#include diff --git a/3rdparty/boost/boost/config/compiler/clang_version.hpp b/3rdparty/boost/boost/config/compiler/clang_version.hpp new file mode 100644 index 0000000000..70c5507c43 --- /dev/null +++ b/3rdparty/boost/boost/config/compiler/clang_version.hpp @@ -0,0 +1,83 @@ +// 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 diff --git a/3rdparty/boost/boost/config/compiler/codegear.hpp b/3rdparty/boost/boost/config/compiler/codegear.hpp index 52531d2f08..77949aaf46 100644 --- a/3rdparty/boost/boost/config/compiler/codegear.hpp +++ b/3rdparty/boost/boost/config/compiler/codegear.hpp @@ -9,6 +9,155 @@ // CodeGear C++ compiler setup: +// +// versions check: +// 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 +# pragma message( "boost: Unknown compiler version - please run the configure tests and report the results") +# 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 : +// +#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 @@ -17,16 +166,6 @@ # 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) -# if defined(BOOST_ASSERT_CONFIG) -# error "boost: Unknown compiler version - please run the configure tests and report the results" -# else -# pragma message( "boost: Unknown compiler version - please run the configure tests and report the results") -# endif -#endif // CodeGear C++ Builder 2009 #if (__CODEGEARC__ <= 0x613) @@ -78,6 +217,8 @@ # define BOOST_HAS_PRAGMA_ONCE #endif +#define BOOST_NO_FENV_H + // // C++0x macros: // @@ -123,7 +264,10 @@ #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) @@ -237,3 +381,4 @@ #define BOOST_COMPILER "CodeGear C++ version " BOOST_STRINGIZE(__CODEGEARC__) +#endif // #if !defined(__clang__) diff --git a/3rdparty/boost/boost/config/compiler/common_edg.hpp b/3rdparty/boost/boost/config/compiler/common_edg.hpp index 88aba9ac8f..7887b30a29 100644 --- a/3rdparty/boost/boost/config/compiler/common_edg.hpp +++ b/3rdparty/boost/boost/config/compiler/common_edg.hpp @@ -77,37 +77,59 @@ #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) diff --git a/3rdparty/boost/boost/config/compiler/cray.hpp b/3rdparty/boost/boost/config/compiler/cray.hpp index 412ef9efa5..2f1e9e8e18 100644 --- a/3rdparty/boost/boost/config/compiler/cray.hpp +++ b/3rdparty/boost/boost/config/compiler/cray.hpp @@ -201,6 +201,7 @@ #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 @@ -220,6 +221,7 @@ #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 @@ -274,6 +276,7 @@ #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 @@ -293,6 +296,7 @@ #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 @@ -344,6 +348,7 @@ #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. diff --git a/3rdparty/boost/boost/config/compiler/digitalmars.hpp b/3rdparty/boost/boost/config/compiler/digitalmars.hpp index 1466373191..7641ee8a6d 100644 --- a/3rdparty/boost/boost/config/compiler/digitalmars.hpp +++ b/3rdparty/boost/boost/config/compiler/digitalmars.hpp @@ -83,7 +83,9 @@ #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) diff --git a/3rdparty/boost/boost/config/compiler/gcc.hpp b/3rdparty/boost/boost/config/compiler/gcc.hpp index 3380ffed19..4cea0ce26b 100644 --- a/3rdparty/boost/boost/config/compiler/gcc.hpp +++ b/3rdparty/boost/boost/config/compiler/gcc.hpp @@ -249,12 +249,12 @@ # 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 @@ -267,6 +267,20 @@ # 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) @@ -309,9 +323,10 @@ # 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 @@ -325,12 +340,18 @@ // 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 @@ -344,7 +365,7 @@ // 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 // diff --git a/3rdparty/boost/boost/config/compiler/gcc_xml.hpp b/3rdparty/boost/boost/config/compiler/gcc_xml.hpp index bdba4ed092..fd6896a811 100644 --- a/3rdparty/boost/boost/config/compiler/gcc_xml.hpp +++ b/3rdparty/boost/boost/config/compiler/gcc_xml.hpp @@ -61,7 +61,9 @@ # 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) diff --git a/3rdparty/boost/boost/config/compiler/hp_acc.hpp b/3rdparty/boost/boost/config/compiler/hp_acc.hpp index 49d676fa2b..cf5667b520 100644 --- a/3rdparty/boost/boost/config/compiler/hp_acc.hpp +++ b/3rdparty/boost/boost/config/compiler/hp_acc.hpp @@ -125,6 +125,7 @@ #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 diff --git a/3rdparty/boost/boost/config/compiler/intel.hpp b/3rdparty/boost/boost/config/compiler/intel.hpp index f56807dbbc..9a06d2fe3d 100644 --- a/3rdparty/boost/boost/config/compiler/intel.hpp +++ b/3rdparty/boost/boost/config/compiler/intel.hpp @@ -501,8 +501,15 @@ template<> struct assert_intrinsic_wchar_t {}; #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) diff --git a/3rdparty/boost/boost/config/compiler/metrowerks.hpp b/3rdparty/boost/boost/config/compiler/metrowerks.hpp index 0e18e1809e..32c1ca9a2a 100644 --- a/3rdparty/boost/boost/config/compiler/metrowerks.hpp +++ b/3rdparty/boost/boost/config/compiler/metrowerks.hpp @@ -126,7 +126,9 @@ #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) diff --git a/3rdparty/boost/boost/config/compiler/mpw.hpp b/3rdparty/boost/boost/config/compiler/mpw.hpp index 05c066efbc..750d588415 100644 --- a/3rdparty/boost/boost/config/compiler/mpw.hpp +++ b/3rdparty/boost/boost/config/compiler/mpw.hpp @@ -75,7 +75,9 @@ #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) diff --git a/3rdparty/boost/boost/config/compiler/nvcc.hpp b/3rdparty/boost/boost/config/compiler/nvcc.hpp index ed035fcf73..419dd724ac 100644 --- a/3rdparty/boost/boost/config/compiler/nvcc.hpp +++ b/3rdparty/boost/boost/config/compiler/nvcc.hpp @@ -22,6 +22,7 @@ // 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 @@ -38,6 +39,8 @@ # 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: diff --git a/3rdparty/boost/boost/config/compiler/pathscale.hpp b/3rdparty/boost/boost/config/compiler/pathscale.hpp index 1318d275ad..683b0d31ba 100644 --- a/3rdparty/boost/boost/config/compiler/pathscale.hpp +++ b/3rdparty/boost/boost/config/compiler/pathscale.hpp @@ -88,7 +88,9 @@ # 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) diff --git a/3rdparty/boost/boost/config/compiler/sunpro_cc.hpp b/3rdparty/boost/boost/config/compiler/sunpro_cc.hpp index 41b7bcade6..1ab789912c 100644 --- a/3rdparty/boost/boost/config/compiler/sunpro_cc.hpp +++ b/3rdparty/boost/boost/config/compiler/sunpro_cc.hpp @@ -86,6 +86,12 @@ # 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 @@ -123,6 +129,8 @@ #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) diff --git a/3rdparty/boost/boost/config/compiler/vacpp.hpp b/3rdparty/boost/boost/config/compiler/vacpp.hpp index 8e26449968..0280fe2958 100644 --- a/3rdparty/boost/boost/config/compiler/vacpp.hpp +++ b/3rdparty/boost/boost/config/compiler/vacpp.hpp @@ -137,7 +137,9 @@ #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) diff --git a/3rdparty/boost/boost/config/compiler/visualc.hpp b/3rdparty/boost/boost/config/compiler/visualc.hpp index 092252e3a1..6378094c0c 100644 --- a/3rdparty/boost/boost/config/compiler/visualc.hpp +++ b/3rdparty/boost/boost/config/compiler/visualc.hpp @@ -107,6 +107,14 @@ # 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: // @@ -144,6 +152,7 @@ # 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). @@ -185,6 +194,7 @@ # 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) // @@ -234,7 +244,9 @@ // 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: @@ -281,6 +293,17 @@ # 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 diff --git a/3rdparty/boost/boost/config/compiler/xlcpp.hpp b/3rdparty/boost/boost/config/compiler/xlcpp.hpp index ee7aa1253a..f002e69c91 100644 --- a/3rdparty/boost/boost/config/compiler/xlcpp.hpp +++ b/3rdparty/boost/boost/config/compiler/xlcpp.hpp @@ -194,6 +194,11 @@ #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__)) @@ -265,6 +270,10 @@ # 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) @@ -283,3 +292,4 @@ // Macro used to identify the Clang compiler. #define BOOST_CLANG 1 +#define BOOST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) diff --git a/3rdparty/boost/boost/config/compiler/xlcpp_zos.hpp b/3rdparty/boost/boost/config/compiler/xlcpp_zos.hpp index eb1bf2e992..bc5b7e831f 100644 --- a/3rdparty/boost/boost/config/compiler/xlcpp_zos.hpp +++ b/3rdparty/boost/boost/config/compiler/xlcpp_zos.hpp @@ -140,7 +140,9 @@ #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 diff --git a/3rdparty/boost/boost/config/detail/cxx_composite.hpp b/3rdparty/boost/boost/config/detail/cxx_composite.hpp new file mode 100644 index 0000000000..a243d41f8e --- /dev/null +++ b/3rdparty/boost/boost/config/detail/cxx_composite.hpp @@ -0,0 +1,203 @@ +// 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 + diff --git a/3rdparty/boost/boost/config/detail/select_compiler_config.hpp b/3rdparty/boost/boost/config/detail/select_compiler_config.hpp index 8970dffb4f..c3d99e1a43 100644 --- a/3rdparty/boost/boost/config/detail/select_compiler_config.hpp +++ b/3rdparty/boost/boost/config/detail/select_compiler_config.hpp @@ -39,7 +39,7 @@ // 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" diff --git a/3rdparty/boost/boost/config/detail/select_platform_config.hpp b/3rdparty/boost/boost/config/detail/select_platform_config.hpp index b36eca57a2..dbff74aaf7 100644 --- a/3rdparty/boost/boost/config/detail/select_platform_config.hpp +++ b/3rdparty/boost/boost/config/detail/select_platform_config.hpp @@ -88,6 +88,11 @@ #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) \ diff --git a/3rdparty/boost/boost/config/detail/select_stdlib_config.hpp b/3rdparty/boost/boost/config/detail/select_stdlib_config.hpp index 8db778c86b..1a09dda126 100644 --- a/3rdparty/boost/boost/config/detail/select_stdlib_config.hpp +++ b/3rdparty/boost/boost/config/detail/select_stdlib_config.hpp @@ -11,10 +11,21 @@ // locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed: -// First include to determine if some version of STLport is in use as the std lib +// First, check if __has_include is available and include can be located, +// otherwise include 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() +// It should be safe to include `` when it is present without checking +// the actual C++ language version as it consists solely of macro definitions. +// [version.syn] p1: The header supplies implementation-dependent +// information about the C++ standard library (e.g., version number and release date). +# include +# else +# include +# endif +#elif defined(__cplusplus) # include #else # include diff --git a/3rdparty/boost/boost/config/detail/suffix.hpp b/3rdparty/boost/boost/config/detail/suffix.hpp index 47e139b4e1..898c7ac473 100644 --- a/3rdparty/boost/boost/config/detail/suffix.hpp +++ b/3rdparty/boost/boost/config/detail/suffix.hpp @@ -35,7 +35,7 @@ #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 @@ -47,6 +47,22 @@ # 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 . // Note that we use limits.h rather than climits for maximal portability, @@ -54,7 +70,7 @@ // 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 # if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) # define BOOST_HAS_LONG_LONG @@ -475,6 +491,16 @@ namespace std { # 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 @@ -529,10 +555,13 @@ namespace boost { # 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 namespace std{ using ::type_info; } +// Since we do now have typeinfo, undef the macro: +#undef BOOST_NO_STD_TYPEINFO #endif // ---------------------------------------------------------------------------// @@ -619,6 +648,9 @@ namespace std{ using ::type_info; } // 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 @@ -634,7 +666,7 @@ namespace std{ using ::type_info; } #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) @@ -652,6 +684,23 @@ namespace std{ using ::type_info; } # 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 // @@ -667,6 +716,12 @@ namespace std{ using ::type_info; } # 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) @@ -1002,6 +1057,16 @@ namespace std{ using ::type_info; } #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: @@ -1012,9 +1077,16 @@ namespace std{ using ::type_info; } // // [[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)) @@ -1030,6 +1102,12 @@ namespace std{ using ::type_info; } #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 // @@ -1064,6 +1142,11 @@ namespace std{ using ::type_info; } # 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() # define BOOST_NO_CXX17_HDR_OPTIONAL @@ -1074,8 +1157,113 @@ namespace std{ using ::type_info; } #if !__has_include() # define BOOST_NO_CXX17_HDR_VARIANT #endif +#if !__has_include() +# define BOOST_NO_CXX17_HDR_ANY +#endif +#if !__has_include() +# define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE +#endif +#if !__has_include() +# define BOOST_NO_CXX17_HDR_CHARCONV +#endif +#if !__has_include() +# define BOOST_NO_CXX17_HDR_EXECUTION +#endif +#if !__has_include() +# 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() || !defined(__cpp_lib_barrier) || (__cpp_lib_barrier < 201907L)) && !defined(BOOST_NO_CXX20_HDR_BARRIER) +# define BOOST_NO_CXX20_HDR_BARRIER +#endif +#if (!__has_include() || !defined(__cpp_lib_format) || (__cpp_lib_format < 201907L)) && !defined(BOOST_NO_CXX20_HDR_FORMAT) +# define BOOST_NO_CXX20_HDR_FORMAT +#endif +#if (!__has_include() || !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() || !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() || !defined(__cpp_lib_latch) || (__cpp_lib_latch < 201907L)) && !defined(BOOST_NO_CXX20_HDR_LATCH) +# define BOOST_NO_CXX20_HDR_LATCH +#endif +#if (!__has_include() || !defined(__cpp_lib_span) || (__cpp_lib_span < 202002L)) && !defined(BOOST_NO_CXX20_HDR_SPAN) +# define BOOST_NO_CXX20_HDR_SPAN +#endif +#if (!__has_include() || !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() || !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() || !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() || !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() || !defined(__cpp_lib_ranges) || (__cpp_lib_ranges < 201911L)) && !defined(BOOST_NO_CXX20_HDR_RANGES) +# define BOOST_NO_CXX20_HDR_RANGES +#endif +#if (!__has_include() || !defined(__cpp_lib_syncbuf) || (__cpp_lib_syncbuf < 201803L)) && !defined(BOOST_NO_CXX20_HDR_SYNCSTREAM) +# define BOOST_NO_CXX20_HDR_SYNCSTREAM +#endif +#if (!__has_include() || !defined(__cpp_lib_coroutine) || (__cpp_lib_coroutine < 201902L)) && !defined(BOOST_NO_CXX20_HDR_COROUTINE) +# define BOOST_NO_CXX20_HDR_COROUTINE +#endif +#if (!__has_include() || !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() +# define BOOST_NO_CXX20_HDR_VERSION +#else +// For convenience, this is always included: +# include +#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 // // Finish off with checks for macros that are depricated / no longer supported, diff --git a/3rdparty/boost/boost/config/header_deprecated.hpp b/3rdparty/boost/boost/config/header_deprecated.hpp index 864554f2a2..120b4b3a92 100644 --- a/3rdparty/boost/boost/config/header_deprecated.hpp +++ b/3rdparty/boost/boost/config/header_deprecated.hpp @@ -17,7 +17,7 @@ #include -#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.") diff --git a/3rdparty/boost/boost/config/platform/bsd.hpp b/3rdparty/boost/boost/config/platform/bsd.hpp index 79e74a080a..ccc7eb05ad 100644 --- a/3rdparty/boost/boost/config/platform/bsd.hpp +++ b/3rdparty/boost/boost/config/platform/bsd.hpp @@ -28,7 +28,8 @@ // FreeBSD has but does not // advertise the fact in : // -#if (defined(__FreeBSD__) && (__FreeBSD__ >= 3)) || defined(__DragonFly__) +#if (defined(__FreeBSD__) && (__FreeBSD__ >= 3)) \ + || defined(__OpenBSD__) || defined(__DragonFly__) # define BOOST_HAS_NL_TYPES_H #endif @@ -56,7 +57,8 @@ #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 // @@ -74,13 +76,8 @@ #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 - - - - - - diff --git a/3rdparty/boost/boost/config/platform/wasm.hpp b/3rdparty/boost/boost/config/platform/wasm.hpp new file mode 100644 index 0000000000..682b84859a --- /dev/null +++ b/3rdparty/boost/boost/config/platform/wasm.hpp @@ -0,0 +1,23 @@ +// (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() +# define BOOST_HAS_UNISTD_H +#endif +#endif + +// boilerplate code: +#include +// +// fenv lacks the C++11 macros: +// +#define BOOST_NO_FENV_H diff --git a/3rdparty/boost/boost/config/requires_threads.hpp b/3rdparty/boost/boost/config/requires_threads.hpp index cfaff23027..c23a2ce3c9 100644 --- a/3rdparty/boost/boost/config/requires_threads.hpp +++ b/3rdparty/boost/boost/config/requires_threads.hpp @@ -54,7 +54,7 @@ // 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" diff --git a/3rdparty/boost/boost/config/stdlib/dinkumware.hpp b/3rdparty/boost/boost/config/stdlib/dinkumware.hpp index 7d565653bd..8feccc65af 100644 --- a/3rdparty/boost/boost/config/stdlib/dinkumware.hpp +++ b/3rdparty/boost/boost/config/stdlib/dinkumware.hpp @@ -22,7 +22,7 @@ #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) @@ -68,12 +68,12 @@ // 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) @@ -86,20 +86,24 @@ # 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 // header before including the 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 #endif #include -#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) // @@ -172,17 +176,29 @@ #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 @@ -203,7 +219,15 @@ // 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) +// +// 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 @@ -218,6 +242,12 @@ # define BOOST_NO_CXX98_BINDERS # endif #endif +// +// Things deprecated in C++20: +// +#if defined(_HAS_CXX20) +# define BOOST_NO_CXX11_ATOMIC_SMART_PTR +#endif // diff --git a/3rdparty/boost/boost/config/stdlib/libcpp.hpp b/3rdparty/boost/boost/config/stdlib/libcpp.hpp index e8eea9117c..0e9f2445ed 100644 --- a/3rdparty/boost/boost/config/stdlib/libcpp.hpp +++ b/3rdparty/boost/boost/config/stdlib/libcpp.hpp @@ -104,8 +104,34 @@ # define BOOST_NO_CXX98_BINDERS #endif -#define BOOST_NO_CXX17_ITERATOR_TRAITS +#if defined(__cplusplus) && defined(__has_include) +#if __has_include() +#include + +#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 @@ -142,4 +168,13 @@ # 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 --- diff --git a/3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp b/3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp index c4c9996026..85ad1a6bde 100644 --- a/3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp +++ b/3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp @@ -94,6 +94,20 @@ #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: // @@ -125,7 +139,13 @@ // #ifdef __clang__ -#if __has_include() +#if __has_include() +# define BOOST_LIBSTDCXX_VERSION 120100 +#elif __has_include() +# define BOOST_LIBSTDCXX_VERSION 110100 +#elif __has_include() +# define BOOST_LIBSTDCXX_VERSION 100100 +#elif __has_include() # define BOOST_LIBSTDCXX_VERSION 90100 #elif __has_include() # define BOOST_LIBSTDCXX_VERSION 80100 @@ -150,6 +170,33 @@ #elif __has_include() # 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, @@ -214,6 +261,7 @@ extern "C" char *gets (char *__s); # endif # elif !_GLIBCXX_USE_DEPRECATED # define BOOST_NO_AUTO_PTR +# define BOOST_NO_CXX98_BINDERS # endif #endif @@ -286,10 +334,6 @@ extern "C" char *gets (char *__s); # 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 throws up errors with clang: -# define BOOST_NO_CXX11_HDR_ATOMIC -#endif // // C++0x features in GCC 5.1 and later // @@ -317,10 +361,76 @@ extern "C" char *gets (char *__s); #elif __cplusplus <= 201103 # define BOOST_NO_CXX14_HDR_SHARED_MUTEX #endif +// +// has a dependency to Intel's thread building blocks: +// unless these are installed seperately, including leads +// to inscrutable errors inside libstdc++'s own headers. +// +#if (BOOST_LIBSTDCXX_VERSION < 100100) +#if !__has_include() +#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 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 : +# 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) @@ -349,7 +459,7 @@ extern "C" char *gets (char *__s); # 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 diff --git a/3rdparty/boost/boost/config/stdlib/roguewave.hpp b/3rdparty/boost/boost/config/stdlib/roguewave.hpp index 0c5c113ea3..03a65768c0 100644 --- a/3rdparty/boost/boost/config/stdlib/roguewave.hpp +++ b/3rdparty/boost/boost/config/stdlib/roguewave.hpp @@ -59,7 +59,7 @@ // // Borland version of numeric_limits lacks __int64 specialisation: // -#ifdef __BORLANDC__ +#ifdef BOOST_BORLANDC # define BOOST_NO_MS_INT64_NUMERIC_LIMITS #endif diff --git a/3rdparty/boost/boost/config/stdlib/stlport.hpp b/3rdparty/boost/boost/config/stdlib/stlport.hpp index 094e27bb74..38bc763f95 100644 --- a/3rdparty/boost/boost/config/stdlib/stlport.hpp +++ b/3rdparty/boost/boost/config/stdlib/stlport.hpp @@ -62,11 +62,11 @@ // 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 @@ -128,7 +128,7 @@ // 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 @@ -143,7 +143,7 @@ # 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 namespace std { using ::abs; } @@ -192,7 +192,7 @@ namespace std{ using _STLP_VENDOR_CSTD::strcmp; using _STLP_VENDOR_CSTD::strcpy; // 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 diff --git a/3rdparty/boost/boost/config/workaround.hpp b/3rdparty/boost/boost/config/workaround.hpp index fca8f3ab7e..688f963660 100644 --- a/3rdparty/boost/boost/config/workaround.hpp +++ b/3rdparty/boost/boost/config/workaround.hpp @@ -50,6 +50,21 @@ #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 @@ -177,6 +192,11 @@ #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 @@ -239,6 +259,12 @@ #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 diff --git a/3rdparty/boost/boost/container_hash/detail/float_functions.hpp b/3rdparty/boost/boost/container_hash/detail/float_functions.hpp deleted file mode 100644 index f3db52f9cc..0000000000 --- a/3rdparty/boost/boost/container_hash/detail/float_functions.hpp +++ /dev/null @@ -1,336 +0,0 @@ - -// 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 -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include - -// 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 - struct call_ldexp { - typedef Float float_type; - inline Float operator()(Float x, int y) const { - return std::ldexp(x, y); - } - }; - - template - struct call_frexp { - typedef Float float_type; - inline Float operator()(Float x, int* y) const { - return std::frexp(x, y); - } - }; - - template - 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 struct is; - template <> struct is { char x[10]; }; - template <> struct is { char x[20]; }; - template <> struct is { char x[30]; }; - template <> struct is { char x[40]; }; - - // Used to convert the return type of a function to a type for sizeof. - - template is float_type(T); - - // call_ldexp - // - // This will get specialized for float and long double - - template 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 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 boost::hash_detail::not_found ldexp(Float, int); - template 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 \ - 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)); \ - BOOST_STATIC_CONSTANT(bool, c99 = \ - sizeof(float_type(c99_func(x,y))) \ - == sizeof(is)); \ - }; \ - } \ - \ - template \ - struct call_c99_##c99_func : \ - boost::hash_detail::call_##cpp_func {}; \ - \ - template <> \ - struct call_c99_##c99_func { \ - typedef type1 float_type; \ - \ - template \ - inline type1 operator()(type1 a, T b) const \ - { \ - using namespace std; \ - return c99_func(a, b); \ - } \ - }; \ - \ - template \ - struct call_cpp_##c99_func : \ - call_c99_##c99_func< \ - ::boost::hash_detail::c99_func##_detect::check::c99 \ - > {}; \ - \ - template <> \ - struct call_cpp_##c99_func { \ - typedef type1 float_type; \ - \ - template \ - inline type1 operator()(type1 a, T b) const \ - { \ - using namespace std; \ - return cpp_func(a, b); \ - } \ - }; \ - \ - template <> \ - struct call_##cpp_func : \ - 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 { \ - 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 - struct select_hash_type_impl { - typedef double type; - }; - - template <> - struct select_hash_type_impl { - typedef float type; - }; - - template <> - struct select_hash_type_impl { - 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 - struct select_hash_type : select_hash_type_impl< - BOOST_DEDUCED_TYPENAME call_ldexp::float_type, - BOOST_DEDUCED_TYPENAME call_frexp::float_type - > {}; - } -} - -#endif // BOOST_HASH_CONFORMANT_FLOATS - -#endif diff --git a/3rdparty/boost/boost/container_hash/detail/hash_float.hpp b/3rdparty/boost/boost/container_hash/detail/hash_float.hpp deleted file mode 100644 index f763428508..0000000000 --- a/3rdparty/boost/boost/container_hash/detail/hash_float.hpp +++ /dev/null @@ -1,271 +0,0 @@ - -// 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 -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include -#include -#include -#include -#include -#include -#include -#include - -#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 - struct enable_binary_hash - { - BOOST_STATIC_CONSTANT(bool, value = - std::numeric_limits::is_iec559 && - std::numeric_limits::digits == digits && - std::numeric_limits::radix == 2 && - std::numeric_limits::max_exponent == max_exponent); - }; - - template - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME boost::enable_if_c< - enable_binary_hash::value, - std::size_t>::type) - { - return hash_binary((char*) &v, 4); - } - - - template - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME boost::enable_if_c< - enable_binary_hash::value, - std::size_t>::type) - { - return hash_binary((char*) &v, 8); - } - - template - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME boost::enable_if_c< - enable_binary_hash::value, - std::size_t>::type) - { - return hash_binary((char*) &v, 10); - } - - template - inline std::size_t float_hash_impl(Float v, - BOOST_DEDUCED_TYPENAME boost::enable_if_c< - enable_binary_hash::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 - inline std::size_t float_hash_impl2(T v) - { - boost::hash_detail::call_frexp frexp; - boost::hash_detail::call_ldexp 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::max_exponent - - limits::min_exponent; - } - - v = ldexp(v, limits::digits); - std::size_t seed = static_cast(v); - v -= static_cast(seed); - - // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1; - std::size_t const length - = (limits::digits * - boost::static_log2::radix>::value - + limits::digits - 1) - / limits::digits; - - for(std::size_t i = 0; i != length; ++i) - { - v = ldexp(v, limits::digits); - std::size_t part = static_cast(v); - v -= static_cast(part); - hash_float_combine(seed, part); - } - - hash_float_combine(seed, static_cast(exp)); - - return seed; - } - -#if !defined(BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC) - template - inline std::size_t float_hash_impl(T v, ...) - { - typedef BOOST_DEDUCED_TYPENAME select_hash_type::type type; - return float_hash_impl2(static_cast(v)); - } -#endif - } -} - -#if BOOST_HASH_USE_FPCLASSIFY - -#include - -namespace boost -{ - namespace hash_detail - { - template - 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 - 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()(v, 0); -#endif - } - - template - 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 diff --git a/3rdparty/boost/boost/container_hash/detail/hash_mix.hpp b/3rdparty/boost/boost/container_hash/detail/hash_mix.hpp new file mode 100644 index 0000000000..327da9e51c --- /dev/null +++ b/3rdparty/boost/boost/container_hash/detail/hash_mix.hpp @@ -0,0 +1,113 @@ +// 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 +#include +#include + +namespace boost +{ +namespace hash_detail +{ + +template 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::fn( v ); +} + +} // namespace hash_detail +} // namespace boost + +#endif // #ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP diff --git a/3rdparty/boost/boost/container_hash/detail/hash_range.hpp b/3rdparty/boost/boost/container_hash/detail/hash_range.hpp new file mode 100644 index 0000000000..28fd239ea6 --- /dev/null +++ b/3rdparty/boost/boost/container_hash/detail/hash_range.hpp @@ -0,0 +1,173 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ +namespace hash_detail +{ + +template struct is_char_type: public boost::false_type {}; + +#if CHAR_BIT == 8 + +template<> struct is_char_type: public boost::true_type {}; +template<> struct is_char_type: public boost::true_type {}; +template<> struct is_char_type: public boost::true_type {}; + +#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L +template<> struct is_char_type: public boost::true_type {}; +#endif + +#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L +template<> struct is_char_type: public boost::true_type {}; +#endif + +#endif + +template +inline typename boost::enable_if_< + !is_char_type::value_type>::value, +std::size_t >::type + hash_range( std::size_t seed, It first, It last ) +{ + for( ; first != last; ++first ) + { + hash_combine::value_type>( seed, *first ); + } + + return seed; +} + +template +inline typename boost::enable_if_< + is_char_type::value_type>::value && + is_same::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( 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( static_cast( first[0] ) ) | + static_cast( static_cast( first[1] ) ) << 8 | + static_cast( static_cast( first[2] ) ) << 16 | + static_cast( static_cast( 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( static_cast( first[0] ) ) | + 0x0100u; + + break; + + case 2: + + w = + static_cast( static_cast( first[0] ) ) | + static_cast( static_cast( first[1] ) ) << 8 | + 0x010000u; + + break; + + case 3: + + w = + static_cast( static_cast( first[0] ) ) | + static_cast( static_cast( first[1] ) ) << 8 | + static_cast( static_cast( first[2] ) ) << 16 | + 0x01000000u; + + break; + } + + hash_combine( seed, w ); + } + + return seed; +} + +template +inline typename boost::enable_if_< + is_char_type::value_type>::value && + !is_same::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( static_cast( *first ) ); + ++first; + + if( first == last ) + { + hash_combine( seed, w | 0x0100u ); + return seed; + } + + w |= static_cast( static_cast( *first ) ) << 8; + ++first; + + if( first == last ) + { + hash_combine( seed, w | 0x010000u ); + return seed; + } + + w |= static_cast( static_cast( *first ) ) << 16; + ++first; + + if( first == last ) + { + hash_combine( seed, w | 0x01000000u ); + return seed; + } + + w |= static_cast( static_cast( *first ) ) << 24; + ++first; + + hash_combine( seed, w ); + } +} + +} // namespace hash_detail +} // namespace boost + +#endif // #ifndef BOOST_HASH_DETAIL_HASH_RANGE_HPP diff --git a/3rdparty/boost/boost/container_hash/detail/hash_tuple.hpp b/3rdparty/boost/boost/container_hash/detail/hash_tuple.hpp new file mode 100644 index 0000000000..597cee9d9e --- /dev/null +++ b/3rdparty/boost/boost/container_hash/detail/hash_tuple.hpp @@ -0,0 +1,133 @@ +// 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 +#include +#include + +#if defined(BOOST_NO_CXX11_HDR_TUPLE) + +// no support + +#else + +#include + +namespace boost +{ +namespace hash_detail +{ + +template +inline typename boost::enable_if_<(I == std::tuple_size::value), + void>::type + hash_combine_tuple(std::size_t&, T const&) +{ +} + +template +inline typename boost::enable_if_<(I < std::tuple_size::value), + void>::type + hash_combine_tuple(std::size_t& seed, T const& v) +{ + boost::hash_combine(seed, std::get(v)); + boost::hash_detail::hash_combine_tuple(seed, v); +} + +template +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 +inline std::size_t hash_value(std::tuple 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 +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple const& v) +{ + return boost::hash_detail::hash_tuple(v); +} + +template +inline std::size_t hash_value(std::tuple 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 diff --git a/3rdparty/boost/boost/container_hash/detail/limits.hpp b/3rdparty/boost/boost/container_hash/detail/limits.hpp deleted file mode 100644 index 4a971a6ac2..0000000000 --- a/3rdparty/boost/boost/container_hash/detail/limits.hpp +++ /dev/null @@ -1,62 +0,0 @@ - -// 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 -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include - -// On OpenBSD, numeric_limits is not reliable for long doubles, but -// the macros defined in are and support long double when STLport -// doesn't. - -#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE) -#include -#endif - -namespace boost -{ - namespace hash_detail - { - template - struct limits : std::numeric_limits {}; - -#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE) - template <> - struct limits - : std::numeric_limits - { - 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 diff --git a/3rdparty/boost/boost/container_hash/extensions.hpp b/3rdparty/boost/boost/container_hash/extensions.hpp deleted file mode 100644 index 4eebb4bc93..0000000000 --- a/3rdparty/boost/boost/container_hash/extensions.hpp +++ /dev/null @@ -1,414 +0,0 @@ - -// 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 -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include -#include -#include -#include -#include - -#if !defined(BOOST_NO_CXX11_HDR_ARRAY) -# include -#endif - -#if !defined(BOOST_NO_CXX11_HDR_TUPLE) -# include -#endif - -#if !defined(BOOST_NO_CXX11_HDR_MEMORY) -# include -#endif - -#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) -#include -#endif - -namespace boost -{ - template - std::size_t hash_value(std::pair const&); - template - std::size_t hash_value(std::vector const&); - template - std::size_t hash_value(std::list const& v); - template - std::size_t hash_value(std::deque const& v); - template - std::size_t hash_value(std::set const& v); - template - std::size_t hash_value(std::multiset const& v); - template - std::size_t hash_value(std::map const& v); - template - std::size_t hash_value(std::multimap const& v); - - template - std::size_t hash_value(std::complex const&); - - template - std::size_t hash_value(std::pair 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::iterator first, - std::vector::iterator last) - { - std::size_t seed = 0; - - for(; first != last; ++first) - { - hash_combine(seed, *first); - } - - return seed; - } - - inline std::size_t hash_range( - std::vector::const_iterator first, - std::vector::const_iterator last) - { - std::size_t seed = 0; - - for(; first != last; ++first) - { - hash_combine(seed, *first); - } - - return seed; - } - - inline void hash_range( - std::size_t& seed, - std::vector::iterator first, - std::vector::iterator last) - { - for(; first != last; ++first) - { - hash_combine(seed, *first); - } - } - - inline void hash_range( - std::size_t& seed, - std::vector::const_iterator first, - std::vector::const_iterator last) - { - for(; first != last; ++first) - { - hash_combine(seed, *first); - } - } - - template - std::size_t hash_value(std::vector const& v) - { - return boost::hash_range(v.begin(), v.end()); - } - - template - std::size_t hash_value(std::list const& v) - { - return boost::hash_range(v.begin(), v.end()); - } - - template - std::size_t hash_value(std::deque const& v) - { - return boost::hash_range(v.begin(), v.end()); - } - - template - std::size_t hash_value(std::set const& v) - { - return boost::hash_range(v.begin(), v.end()); - } - - template - std::size_t hash_value(std::multiset const& v) - { - return boost::hash_range(v.begin(), v.end()); - } - - template - std::size_t hash_value(std::map const& v) - { - return boost::hash_range(v.begin(), v.end()); - } - - template - std::size_t hash_value(std::multimap const& v) - { - return boost::hash_range(v.begin(), v.end()); - } - - template - std::size_t hash_value(std::complex const& v) - { - boost::hash 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 - std::size_t hash_value(std::array const& v) - { - return boost::hash_range(v.begin(), v.end()); - } -#endif - -#if !defined(BOOST_NO_CXX11_HDR_TUPLE) - namespace hash_detail { - template - inline typename boost::enable_if_c<(I == std::tuple_size::value), - void>::type - hash_combine_tuple(std::size_t&, T const&) - { - } - - template - inline typename boost::enable_if_c<(I < std::tuple_size::value), - void>::type - hash_combine_tuple(std::size_t& seed, T const& v) - { - boost::hash_combine(seed, std::get(v)); - boost::hash_detail::hash_combine_tuple(seed, v); - } - - template - 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 - inline std::size_t hash_value(std::tuple 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 - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - - template - inline std::size_t hash_value(std::tuple const& v) - { - return boost::hash_detail::hash_tuple(v); - } - -#endif - -#endif - -#if !defined(BOOST_NO_CXX11_SMART_PTR) - template - inline std::size_t hash_value(std::shared_ptr const& x) { - return boost::hash_value(x.get()); - } - - template - inline std::size_t hash_value(std::unique_ptr 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 - struct call_hash_impl - { - template - struct inner - { - static std::size_t call(T const& v) - { - using namespace boost; - return hash_value(v); - } - }; - }; - - template <> - struct call_hash_impl - { - template - 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 - struct call_hash - : public call_hash_impl::value> - ::BOOST_NESTED_TEMPLATE inner - { - }; - } -#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING - - // - // boost::hash - // - - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - template struct hash - : boost::hash_detail::hash_base - { -#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::call(val); - } -#endif - }; - -#if BOOST_WORKAROUND(__DMC__, <= 0x848) - template struct hash - : boost::hash_detail::hash_base - { - 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 - // has already been declared to deal with pointers, so just - // need to supply the non-pointer version of hash_impl. - - namespace hash_detail - { - template - struct hash_impl; - - template <> - struct hash_impl - { - template - struct inner - : boost::hash_detail::hash_base - { -#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::call(val); - } -#endif - }; - }; - } -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -} - -#endif diff --git a/3rdparty/boost/boost/container_hash/hash.hpp b/3rdparty/boost/boost/container_hash/hash.hpp index 76de7939eb..306c279164 100644 --- a/3rdparty/boost/boost/container_hash/hash.hpp +++ b/3rdparty/boost/boost/container_hash/hash.hpp @@ -1,33 +1,50 @@ - // 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) +// Copyright 2021, 2022 Peter Dimov. +// Distributed under the Boost Software License, Version 1.0. +// https://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: +// Based on Peter Dimov's proposal +// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf +// issue 6.18. -// MurmurHash3 was written by Austin Appleby, and is placed in the public -// domain. The author hereby disclaims copyright to this source code. - -#if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP) +#ifndef BOOST_FUNCTIONAL_HASH_HASH_HPP #define BOOST_FUNCTIONAL_HASH_HASH_HPP #include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include #include #include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -#include +#if defined(BOOST_DESCRIBE_CXX14) +# include +#endif + +#include +#include +#include +#include +#include +#include +#include + +#if !defined(BOOST_NO_CXX11_SMART_PTR) +# include #endif #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) @@ -38,724 +55,608 @@ #include #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. +#if !defined(BOOST_NO_CXX17_HDR_OPTIONAL) +#include #endif +#if !defined(BOOST_NO_CXX17_HDR_VARIANT) +#include #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 -#endif - -#if !defined(BOOST_HASH_CXX17) -# define BOOST_HASH_CXX17 0 -#endif - -#if BOOST_HASH_CXX17 && defined(__has_include) -# if !defined(BOOST_HASH_HAS_STRING_VIEW) && __has_include() -# define BOOST_HASH_HAS_STRING_VIEW 1 -# endif -# if !defined(BOOST_HASH_HAS_OPTIONAL) && __has_include() -# define BOOST_HASH_HAS_OPTIONAL 1 -# endif -# if !defined(BOOST_HASH_HAS_VARIANT) && __has_include() -# define BOOST_HASH_HAS_VARIANT 1 -# endif -#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 -#endif - -#if BOOST_HASH_HAS_OPTIONAL -# include -#endif - -#if BOOST_HASH_HAS_VARIANT -# include +#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW) +# include #endif namespace boost { + + // + // boost::hash_value + // + + // integral types + namespace hash_detail { -#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC - template - struct hash_base + template sizeof(std::size_t)), + bool is_unsigned = boost::is_unsigned::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 struct hash_integral_impl { - typedef T argument_type; - typedef std::size_t result_type; + static std::size_t fn( T v ) + { + return static_cast( v ); + } }; -#else - template - struct hash_base : std::unary_function {}; -#endif - struct enable_hash_value { typedef std::size_t type; }; + template struct hash_integral_impl + { + static std::size_t fn( T v ) + { + typedef typename boost::make_unsigned::type U; - template struct basic_numbers {}; - template struct long_numbers; - template struct ulong_numbers; - template struct float_numbers {}; + if( v >= 0 ) + { + return hash_integral_impl::fn( static_cast( v ) ); + } + else + { + return ~hash_integral_impl::fn( static_cast( ~static_cast( v ) ) ); + } + } + }; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; + template struct hash_integral_impl + { + static std::size_t fn( T v ) + { + std::size_t seed = 0; -#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; -#endif + seed = static_cast( v >> 32 ) + hash_detail::hash_mix( seed ); + seed = static_cast( v ) + hash_detail::hash_mix( seed ); -#if !defined(BOOST_NO_CXX11_CHAR16_T) - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; -#endif + return seed; + } + }; -#if !defined(BOOST_NO_CXX11_CHAR32_T) - template <> struct basic_numbers : - boost::hash_detail::enable_hash_value {}; -#endif + template struct hash_integral_impl + { + static std::size_t fn( T v ) + { + std::size_t seed = 0; - // long_numbers is defined like this to allow for separate - // specialization for long_long and int128_type, in case - // they conflict. - template struct long_numbers2 {}; - template struct ulong_numbers2 {}; - template struct long_numbers : long_numbers2 {}; - template struct ulong_numbers : ulong_numbers2 {}; + seed = static_cast( v >> 96 ) + hash_detail::hash_mix( seed ); + seed = static_cast( v >> 64 ) + hash_detail::hash_mix( seed ); + seed = static_cast( v >> 32 ) + hash_detail::hash_mix( seed ); + seed = static_cast( v ) + hash_detail::hash_mix( seed ); -#if !defined(BOOST_NO_LONG_LONG) - template <> struct long_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct ulong_numbers : - boost::hash_detail::enable_hash_value {}; -#endif + return seed; + } + }; -#if defined(BOOST_HAS_INT128) - template <> struct long_numbers2 : - boost::hash_detail::enable_hash_value {}; - template <> struct ulong_numbers2 : - boost::hash_detail::enable_hash_value {}; -#endif + template struct hash_integral_impl + { + static std::size_t fn( T v ) + { + std::size_t seed = 0; - template <> struct float_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct float_numbers : - boost::hash_detail::enable_hash_value {}; - template <> struct float_numbers : - boost::hash_detail::enable_hash_value {}; + seed = static_cast( v >> 64 ) + hash_detail::hash_mix( seed ); + seed = static_cast( v ) + hash_detail::hash_mix( seed ); + + return seed; + } + }; + + } // namespace hash_detail + + template + typename boost::enable_if_::value, std::size_t>::type + hash_value( T v ) + { + return hash_detail::hash_integral_impl::fn( v ); } - template - typename boost::hash_detail::basic_numbers::type hash_value(T); - template - typename boost::hash_detail::long_numbers::type hash_value(T); - template - typename boost::hash_detail::ulong_numbers::type hash_value(T); + // enumeration types template - typename boost::enable_if, std::size_t>::type - hash_value(T); + typename boost::enable_if_::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, make_signed, make_unsigned>::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( v ); + } + + // floating point types + + namespace hash_detail + { + template::digits> + struct hash_float_impl; + + // float + template struct hash_float_impl + { + static std::size_t fn( T v ) + { + boost::uint32_t w; + std::memcpy( &w, &v, sizeof( v ) ); + + return w; + } + }; + + // double + template struct hash_float_impl + { + static std::size_t fn( T v ) + { + boost::uint64_t w; + std::memcpy( &w, &v, sizeof( v ) ); + + return hash_value( w ); + } + }; + + // 80 bit long double in 12 bytes + template struct hash_float_impl + { + static std::size_t fn( T v ) + { + boost::uint64_t w[ 2 ] = {}; + std::memcpy( &w, &v, 80 / CHAR_BIT ); + + std::size_t seed = 0; + + seed = hash_value( w[0] ) + hash_detail::hash_mix( seed ); + seed = hash_value( w[1] ) + hash_detail::hash_mix( seed ); + + return seed; + } + }; + + // 80 bit long double in 16 bytes + template struct hash_float_impl + { + static std::size_t fn( T v ) + { + boost::uint64_t w[ 2 ] = {}; + std::memcpy( &w, &v, 80 / CHAR_BIT ); + + std::size_t seed = 0; + + seed = hash_value( w[0] ) + hash_detail::hash_mix( seed ); + seed = hash_value( w[1] ) + hash_detail::hash_mix( seed ); + + return seed; + } + }; + + // 128 bit long double + template struct hash_float_impl + { + static std::size_t fn( T v ) + { + boost::uint64_t w[ 2 ]; + std::memcpy( &w, &v, sizeof( v ) ); + + std::size_t seed = 0; + +#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__ + + seed = hash_value( w[1] ) + hash_detail::hash_mix( seed ); + seed = hash_value( w[0] ) + hash_detail::hash_mix( seed ); -#if !BOOST_WORKAROUND(__DMC__, <= 0x848) - template std::size_t hash_value(T* const&); #else - template std::size_t hash_value(T*); + + seed = hash_value( w[0] ) + hash_detail::hash_mix( seed ); + seed = hash_value( w[1] ) + hash_detail::hash_mix( seed ); + +#endif + return seed; + } + }; + + } // namespace hash_detail + + template + typename boost::enable_if_::value, std::size_t>::type + hash_value( T v ) + { + return boost::hash_detail::hash_float_impl::fn( v + 0 ); + } + + // pointer types + + // `x + (x >> 3)` adjustment by Alberto Barbati and Dave Harris. + template std::size_t hash_value( T* const& v ) + { + boost::uintptr_t x = reinterpret_cast( v ); + return boost::hash_value( x + (x >> 3) ); + } + + // array types + + template + inline std::size_t hash_value( T const (&x)[ N ] ) + { + return boost::hash_range( x, x + N ); + } + + template + inline std::size_t hash_value( T (&x)[ N ] ) + { + return boost::hash_range( x, x + N ); + } + + // complex + + template + std::size_t hash_value( std::complex const& v ) + { + std::size_t re = boost::hash()( v.real() ); + std::size_t im = boost::hash()( v.imag() ); + + return re + hash_detail::hash_mix( im ); + } + + // pair + + template + std::size_t hash_value( std::pair const& v ) + { + std::size_t seed = 0; + + boost::hash_combine( seed, v.first ); + boost::hash_combine( seed, v.second ); + + return seed; + } + + // ranges (list, set, deque...) + + template + typename boost::enable_if_::value && !container_hash::is_contiguous_range::value && !container_hash::is_unordered_range::value, std::size_t>::type + hash_value( T const& v ) + { + return boost::hash_range( v.begin(), v.end() ); + } + + // contiguous ranges (string, vector, array) + + template + typename boost::enable_if_::value, std::size_t>::type + hash_value( T const& v ) + { + return boost::hash_range( v.data(), v.data() + v.size() ); + } + + // unordered ranges (unordered_set, unordered_map) + + template + typename boost::enable_if_::value, std::size_t>::type + hash_value( T const& v ) + { + return boost::hash_unordered_range( v.begin(), v.end() ); + } + +#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 :-/ + + template class L, class... T> + typename boost::enable_if_>::value && !container_hash::is_contiguous_range>::value && !container_hash::is_unordered_range>::value, std::size_t>::type + hash_value( L const& v ) + { + return boost::hash_range( v.begin(), v.end() ); + } + + // contiguous ranges (string, vector, array) + + template class L, class... T> + typename boost::enable_if_>::value, std::size_t>::type + hash_value( L const& v ) + { + return boost::hash_range( v.data(), v.data() + v.size() ); + } + + template class L, class T, std::size_t N> + typename boost::enable_if_>::value, std::size_t>::type + hash_value( L const& v ) + { + return boost::hash_range( v.data(), v.data() + v.size() ); + } + + // unordered ranges (unordered_set, unordered_map) + + template class L, class... T> + typename boost::enable_if_>::value, std::size_t>::type + hash_value( L const& v ) + { + return boost::hash_unordered_range( v.begin(), v.end() ); + } + #endif -#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) - template< class T, unsigned N > - std::size_t hash_value(const T (&x)[N]); + // described classes - template< class T, unsigned N > - std::size_t hash_value(T (&x)[N]); -#endif +#if defined(BOOST_DESCRIBE_CXX14) - template - std::size_t hash_value( - std::basic_string, A> const&); - -#if BOOST_HASH_HAS_STRING_VIEW - template - std::size_t hash_value( - std::basic_string_view > const&); +#if defined(_MSC_VER) && _MSC_VER == 1900 +# pragma warning(push) +# pragma warning(disable: 4100) // unreferenced formal parameter #endif template - typename boost::hash_detail::float_numbers::type hash_value(T); + typename boost::enable_if_::value, std::size_t>::type + hash_value( T const& v ) + { + static_assert( !boost::is_union::value, "described unions are not supported" ); + + std::size_t r = 0; + + using Bd = describe::describe_bases; + + mp11::mp_for_each([&](auto D){ + + using B = typename decltype(D)::type; + boost::hash_combine( r, (B const&)v ); + + }); + + using Md = describe::describe_members; + + mp11::mp_for_each([&](auto D){ + + boost::hash_combine( r, v.*D.pointer ); + + }); + + return r; + } + +#if defined(_MSC_VER) && _MSC_VER == 1900 +# pragma warning(pop) +#endif + +#endif + + // std::unique_ptr, std::shared_ptr + +#if !defined(BOOST_NO_CXX11_SMART_PTR) -#if BOOST_HASH_HAS_OPTIONAL template - std::size_t hash_value(std::optional const&); + std::size_t hash_value( std::shared_ptr const& x ) + { + return boost::hash_value( x.get() ); + } + + template + std::size_t hash_value( std::unique_ptr const& x ) + { + return boost::hash_value( x.get() ); + } + #endif -#if BOOST_HASH_HAS_VARIANT - std::size_t hash_value(std::monostate); - template - std::size_t hash_value(std::variant const&); -#endif + // std::type_index #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) - std::size_t hash_value(std::type_index); + + 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) - std::size_t hash_value(std::error_code const&); - std::size_t hash_value(std::error_condition const&); -#endif - // Implementation - - namespace hash_detail - { - template - inline std::size_t hash_value_signed(T val) - { - const unsigned int size_t_bits = std::numeric_limits::digits; - // ceiling(std::numeric_limits::digits / size_t_bits) - 1 - const int length = (std::numeric_limits::digits - 1) - / static_cast(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; - } - - template - inline std::size_t hash_value_unsigned(T val) - { - const unsigned int size_t_bits = std::numeric_limits::digits; - // ceiling(std::numeric_limits::digits / size_t_bits) - 1 - const int length = (std::numeric_limits::digits - 1) - / static_cast(size_t_bits); - - 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); - - return seed; - } - - template - inline void hash_combine_impl(SizeT& seed, SizeT value) - { - seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2); - } - - inline void hash_combine_impl(boost::uint32_t& h1, - boost::uint32_t k1) - { - const uint32_t c1 = 0xcc9e2d51; - const uint32_t c2 = 0x1b873593; - - k1 *= c1; - k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15); - k1 *= c2; - - h1 ^= k1; - h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13); - h1 = h1*5+0xe6546b64; - } - - -// 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) - - 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; - - k *= m; - k ^= k >> r; - k *= m; - - h ^= k; - h *= m; - - // Completely arbitrary number, to prevent 0's - // from hashing to 0. - h += 0xe6546b64; - } - -#endif // BOOST_NO_INT64_T - } - - template - typename boost::hash_detail::basic_numbers::type hash_value(T v) - { - return static_cast(v); - } - - template - typename boost::hash_detail::long_numbers::type hash_value(T v) - { - return hash_detail::hash_value_signed(v); - } - - template - typename boost::hash_detail::ulong_numbers::type hash_value(T v) - { - return hash_detail::hash_value_unsigned(v); - } - - template - typename boost::enable_if, std::size_t>::type - hash_value(T v) - { - return static_cast(v); - } - - // Implementation by Alberto Barbati and Dave Harris. -#if !BOOST_WORKAROUND(__DMC__, <= 0x848) - template std::size_t hash_value(T* const& v) -#else - template std::size_t hash_value(T* v) -#endif - { -#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( - reinterpret_cast(v)); -#else - std::size_t x = static_cast( - reinterpret_cast(v)); -#endif - return x + (x >> 3); - } - -#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 - - template - inline void hash_combine(std::size_t& seed, T const& v) - { - boost::hash hasher; - return boost::hash_detail::hash_combine_impl(seed, hasher(v)); - } - -#if defined(BOOST_MSVC) -#pragma warning(pop) -#endif - - template - inline std::size_t hash_range(It first, It last) + inline std::size_t hash_value( std::error_code const& v ) { std::size_t seed = 0; - for(; first != last; ++first) - { - hash_combine(seed, *first); - } + boost::hash_combine( seed, v.value() ); + boost::hash_combine( seed, &v.category() ); return seed; } - template - inline void hash_range(std::size_t& seed, It first, It last) - { - for(; first != last; ++first) - { - hash_combine(seed, *first); - } - } - -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) - template - inline std::size_t hash_range(T* first, T* last) + inline std::size_t hash_value( std::error_condition const& v ) { std::size_t seed = 0; - for(; first != last; ++first) - { - boost::hash hasher; - seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2); - } + boost::hash_combine( seed, v.value() ); + boost::hash_combine( seed, &v.category() ); return seed; } - template - inline void hash_range(std::size_t& seed, T* first, T* last) +#endif + + // std::optional + +#if !defined(BOOST_NO_CXX17_HDR_OPTIONAL) + + template + std::size_t hash_value( std::optional const& v ) { - for(; first != last; ++first) + if( !v ) { - boost::hash hasher; - seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2); - } - } -#endif - -#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) - template< class T, unsigned N > - inline std::size_t hash_value(const T (&x)[N]) - { - return hash_range(x, x + N); - } - - template< class T, unsigned N > - inline std::size_t hash_value(T (&x)[N]) - { - return hash_range(x, x + N); - } -#endif - - template - inline std::size_t hash_value( - std::basic_string, A> const& v) - { - return hash_range(v.begin(), v.end()); - } - -#if BOOST_HASH_HAS_STRING_VIEW - template - inline std::size_t hash_value( - std::basic_string_view > const& v) - { - return hash_range(v.begin(), v.end()); - } -#endif - - template - typename boost::hash_detail::float_numbers::type hash_value(T v) - { - return boost::hash_detail::float_hash_value(v); - } - -#if BOOST_HASH_HAS_OPTIONAL - template - inline std::size_t hash_value(std::optional const& v) { - if (!v) { // Arbitray value for empty optional. return 0x12345678; - } else { - boost::hash hf; - return hf(*v); + } + else + { + return boost::hash()(*v); } } + #endif -#if BOOST_HASH_HAS_VARIANT - inline std::size_t hash_value(std::monostate) { + // std::variant + +#if !defined(BOOST_NO_CXX17_HDR_VARIANT) + + inline std::size_t hash_value( std::monostate ) + { return 0x87654321; } template - inline std::size_t hash_value(std::variant 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 - - -#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) - inline std::size_t hash_value(std::type_index v) + std::size_t hash_value( std::variant const& v ) { - return v.hash_code(); - } -#endif - -#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) - 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()); + + hash_combine( seed, v.index() ); + std::visit( [&seed](auto&& x) { hash_combine(seed, x); }, v ); + return seed; } - inline std::size_t hash_value(std::error_condition const& v) { +#endif + + // + // boost::hash_combine + // + + template + inline void hash_combine( std::size_t& seed, T const& v ) + { + seed = boost::hash_detail::hash_mix( seed + 0x9e3779b9 + boost::hash()( v ) ); + } + + // + // boost::hash_range + // + + template + inline void hash_range( std::size_t& seed, It first, It last ) + { + seed = hash_detail::hash_range( seed, first, last ); + } + + template + inline std::size_t hash_range( It first, It last ) + { std::size_t seed = 0; - hash_combine(seed, v.value()); - hash_combine(seed, &v.category()); + + hash_range( seed, first, last ); + + return seed; + } + + // + // boost::hash_unordered_range + // + + template + inline void hash_unordered_range( std::size_t& seed, It first, It last ) + { + std::size_t r = 0; + std::size_t const s2( seed ); + + for( ; first != last; ++first ) + { + std::size_t s3( s2 ); + + hash_combine::value_type>( s3, *first ); + + r += s3; + } + + seed += r; + } + + template + inline std::size_t hash_unordered_range( It first, It last ) + { + std::size_t seed = 0; + + hash_unordered_range( seed, first, last ); + return seed; } -#endif // // boost::hash // - // 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. - - // 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. - // - // These are undefined later. - -#define BOOST_HASH_SPECIALIZE(type) \ - template <> struct hash \ - : public boost::hash_detail::hash_base \ - { \ - std::size_t operator()(type v) const \ - { \ - return boost::hash_value(v); \ - } \ - }; - -#define BOOST_HASH_SPECIALIZE_REF(type) \ - template <> struct hash \ - : public boost::hash_detail::hash_base \ - { \ - std::size_t operator()(type const& v) const \ - { \ - return boost::hash_value(v); \ - } \ - }; - -#define BOOST_HASH_SPECIALIZE_TEMPLATE_REF(type) \ - struct hash \ - : public boost::hash_detail::hash_base \ - { \ - std::size_t operator()(type const& v) const \ - { \ - return boost::hash_value(v); \ - } \ - }; - - 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) -#endif -#if !defined(BOOST_NO_CXX11_CHAR32_T) - BOOST_HASH_SPECIALIZE_REF(std::basic_string) -#endif - -#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) -# endif -# if !defined(BOOST_NO_CXX11_CHAR32_T) - BOOST_HASH_SPECIALIZE_REF(std::basic_string_view) -# endif -#endif - -#if !defined(BOOST_NO_LONG_LONG) - BOOST_HASH_SPECIALIZE(boost::long_long_type) - BOOST_HASH_SPECIALIZE(boost::ulong_long_type) -#endif - -#if defined(BOOST_HAS_INT128) - BOOST_HASH_SPECIALIZE(boost::int128_type) - BOOST_HASH_SPECIALIZE(boost::uint128_type) -#endif - -#if BOOST_HASH_HAS_OPTIONAL - template - BOOST_HASH_SPECIALIZE_TEMPLATE_REF(std::optional) -#endif - -#if !defined(BOOST_HASH_HAS_VARIANT) - template - BOOST_HASH_SPECIALIZE_TEMPLATE_REF(std::variant) - BOOST_HASH_SPECIALIZE(std::monostate) -#endif - -#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) - BOOST_HASH_SPECIALIZE(std::type_index) -#endif - -#undef BOOST_HASH_SPECIALIZE -#undef BOOST_HASH_SPECIALIZE_REF -#undef BOOST_HASH_SPECIALIZE_TEMPLATE_REF - -// Specializing boost::hash for pointers. - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - template - struct hash - : public boost::hash_detail::hash_base + template 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( - reinterpret_cast(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 :-/ - namespace hash_detail + template struct hash< std::basic_string > { - template - struct hash_impl; + typedef std::basic_string argument_type; + typedef std::size_t result_type; - template <> - struct hash_impl + std::size_t operator()( std::basic_string const& val ) const { - template - struct inner - : public boost::hash_detail::hash_base - { - 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( - reinterpret_cast(val)); - - return x + (x >> 3); -#endif - } - }; - }; - } - - template struct hash - : public boost::hash_detail::hash_impl::value> - ::BOOST_NESTED_TEMPLATE inner - { + return boost::hash_value( val ); + } }; #endif -} -#undef BOOST_HASH_CHAR_TRAITS -#undef BOOST_FUNCTIONAL_HASH_ROTL32 + // boost::unordered::hash_is_avalanching -#if defined(BOOST_MSVC) -#pragma warning(pop) + namespace unordered + { + template struct hash_is_avalanching; + template struct hash_is_avalanching< boost::hash< std::basic_string > >: boost::is_integral {}; + + // boost::is_integral 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 > >: boost::true_type {}; #endif -#endif // BOOST_FUNCTIONAL_HASH_HASH_HPP +#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW) -// 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. + template struct hash_is_avalanching< boost::hash< std::basic_string_view > >: boost::is_integral {}; -#if !defined(BOOST_HASH_NO_EXTENSIONS) \ - && !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP) -#include +#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L + template<> struct hash_is_avalanching< boost::hash< std::basic_string_view > >: boost::true_type {}; #endif + +#endif + } // namespace unordered + +} // namespace boost + +#endif // #ifndef BOOST_FUNCTIONAL_HASH_HASH_HPP diff --git a/3rdparty/boost/boost/container_hash/hash_fwd.hpp b/3rdparty/boost/boost/container_hash/hash_fwd.hpp index a87c182d39..489fdd2314 100644 --- a/3rdparty/boost/boost/container_hash/hash_fwd.hpp +++ b/3rdparty/boost/boost/container_hash/hash_fwd.hpp @@ -1,36 +1,36 @@ - // 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) +// Copyright 2021, 2022 Peter Dimov. +// Distributed under the Boost Software License, Version 1.0. +// https://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. - -#if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP) +#ifndef BOOST_FUNCTIONAL_HASH_FWD_HPP #define BOOST_FUNCTIONAL_HASH_FWD_HPP -#include #include -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - - namespace boost { - template struct hash; - template void hash_combine(std::size_t& seed, T const& v); +namespace container_hash +{ - template std::size_t hash_range(It, It); - template void hash_range(std::size_t&, It, It); +template struct is_range; +template struct is_contiguous_range; +template struct is_unordered_range; +template struct is_described_class; -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) - template inline std::size_t hash_range(T*, T*); - template inline void hash_range(std::size_t&, T*, T*); -#endif -} +} // namespace container_hash -#endif +template struct hash; + +template void hash_combine( std::size_t& seed, T const& v ); + +template void hash_range( std::size_t&, It, It ); +template std::size_t hash_range( It, It ); + +template void hash_unordered_range( std::size_t&, It, It ); +template std::size_t hash_unordered_range( It, It ); + +} // namespace boost + +#endif // #ifndef BOOST_FUNCTIONAL_HASH_FWD_HPP diff --git a/3rdparty/boost/boost/container_hash/is_contiguous_range.hpp b/3rdparty/boost/boost/container_hash/is_contiguous_range.hpp new file mode 100644 index 0000000000..0e31c11085 --- /dev/null +++ b/3rdparty/boost/boost/container_hash/is_contiguous_range.hpp @@ -0,0 +1,91 @@ +// 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 +#include +#include +#include + +#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700) && !BOOST_WORKAROUND(BOOST_MSVC, < 1910) + +#include +#include +#include +#include + +namespace boost +{ +namespace hash_detail +{ + +template + integral_constant< bool, is_same::value_type, T>::value && is_integral::value > + is_contiguous_range_check( It first, It last, T const*, T const*, S ); + +template decltype( is_contiguous_range_check( declval().begin(), declval().end(), declval().data(), declval().data() + declval().size(), declval().size() ) ) is_contiguous_range_( int ); +template false_type is_contiguous_range_( ... ); + +template struct is_contiguous_range: decltype( hash_detail::is_contiguous_range_( 0 ) ) +{ +}; + +} // namespace hash_detail + +namespace container_hash +{ + +template struct is_contiguous_range: integral_constant< bool, is_range::value && hash_detail::is_contiguous_range::value > +{ +}; + +} // namespace container_hash +} // namespace boost + +#else // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) + +#include +#include +#include +#if !defined(BOOST_NO_CXX11_HDR_ARRAY) +#include +#endif + +namespace boost +{ +namespace container_hash +{ + +template struct is_contiguous_range: false_type +{ +}; + +template struct is_contiguous_range< std::basic_string >: true_type +{ +}; + +template struct is_contiguous_range< std::basic_string const >: true_type +{ +}; + +#if !defined(BOOST_NO_CXX11_HDR_ARRAY) + +template struct is_contiguous_range< std::array >: true_type +{ +}; + +template struct is_contiguous_range< std::array 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 diff --git a/3rdparty/boost/boost/container_hash/is_described_class.hpp b/3rdparty/boost/boost/container_hash/is_described_class.hpp new file mode 100644 index 0000000000..cd2e1db4d0 --- /dev/null +++ b/3rdparty/boost/boost/container_hash/is_described_class.hpp @@ -0,0 +1,38 @@ +// 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 +#include +#include +#include + +namespace boost +{ +namespace container_hash +{ + +#if defined(BOOST_DESCRIBE_CXX11) + +template struct is_described_class: boost::integral_constant::value && + describe::has_describe_members::value && + !boost::is_union::value> +{ +}; + +#else + +template struct is_described_class: boost::false_type +{ +}; + +#endif + +} // namespace container_hash +} // namespace boost + +#endif // #ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED diff --git a/3rdparty/boost/boost/container_hash/is_range.hpp b/3rdparty/boost/boost/container_hash/is_range.hpp new file mode 100644 index 0000000000..56fbd2e794 --- /dev/null +++ b/3rdparty/boost/boost/container_hash/is_range.hpp @@ -0,0 +1,73 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ +#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700) + +namespace hash_detail +{ + +template + integral_constant< bool, !is_same::type, typename std::iterator_traits::value_type>::value > + is_range_check( It first, It last ); + +template decltype( is_range_check( declval().begin(), declval().end() ) ) is_range_( int ); +template false_type is_range_( ... ); + +} // namespace hash_detail + +namespace container_hash +{ + +template struct is_range: decltype( hash_detail::is_range_( 0 ) ) +{ +}; + +} // namespace container_hash + +#else + +namespace hash_detail +{ + +template struct is_range_: false_type +{ +}; + +template struct is_range_< T, integral_constant< bool, + is_same::value_type>::value && + is_integral::value + > >: true_type +{ +}; + +} // namespace hash_detail + +namespace container_hash +{ + +template struct is_range: hash_detail::is_range_ +{ +}; + +} // namespace container_hash + +#endif // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) + +} // namespace boost + +#endif // #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED diff --git a/3rdparty/boost/boost/container_hash/is_unordered_range.hpp b/3rdparty/boost/boost/container_hash/is_unordered_range.hpp new file mode 100644 index 0000000000..11ee386cd2 --- /dev/null +++ b/3rdparty/boost/boost/container_hash/is_unordered_range.hpp @@ -0,0 +1,39 @@ +// 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 +#include +#include + +namespace boost +{ +namespace hash_detail +{ + +template struct has_hasher_: false_type +{ +}; + +template struct has_hasher_< T, integral_constant< bool, + is_same::value + > >: true_type +{ +}; + +} // namespace hash_detail + +namespace container_hash +{ + +template struct is_unordered_range: integral_constant< bool, is_range::value && hash_detail::has_hasher_::value > +{ +}; + +} // namespace container_hash +} // namespace boost + +#endif // #ifndef BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED diff --git a/3rdparty/boost/boost/core/addressof.hpp b/3rdparty/boost/boost/core/addressof.hpp index f7eab06ba7..5473c36a59 100644 --- a/3rdparty/boost/boost/core/addressof.hpp +++ b/3rdparty/boost/boost/core/addressof.hpp @@ -125,7 +125,7 @@ template 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::get(o, 0); #else @@ -151,7 +151,7 @@ addressof(T (&o)[N]) BOOST_NOEXCEPT } #endif -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) template BOOST_FORCEINLINE T (*addressof(T (&o)[N]) BOOST_NOEXCEPT)[N] diff --git a/3rdparty/boost/boost/core/swap.hpp b/3rdparty/boost/boost/core/swap.hpp index eff6b978df..49e1b2dbb6 100644 --- a/3rdparty/boost/boost/core/swap.hpp +++ b/3rdparty/boost/boost/core/swap.hpp @@ -23,9 +23,12 @@ #include #include -#include //for std::swap (C++11) -#include //for std::swap (C++98) -#include //for std::size_t +#if __cplusplus >= 201103L || defined(BOOST_DINKUMWARE_STDLIB) +#include // for std::swap (C++11) +#else +#include // for std::swap (C++98) +#endif +#include // for std::size_t namespace boost_swap_impl { diff --git a/3rdparty/boost/boost/crc.hpp b/3rdparty/boost/boost/crc.hpp index edd66b0daa..75c23f2c67 100644 --- a/3rdparty/boost/boost/crc.hpp +++ b/3rdparty/boost/boost/crc.hpp @@ -566,7 +566,7 @@ namespace detail 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; @@ -681,7 +681,7 @@ namespace detail // 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; @@ -1773,7 +1773,7 @@ crc_basic::process_bits 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(bits & high_bit_mask) ); + process_bit( (bits & high_bit_mask) != 0 ); } } diff --git a/3rdparty/boost/boost/cstdint.hpp b/3rdparty/boost/boost/cstdint.hpp index 9c88d13b84..967aacfd3e 100644 --- a/3rdparty/boost/boost/cstdint.hpp +++ b/3rdparty/boost/boost/cstdint.hpp @@ -306,7 +306,7 @@ namespace boost // 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) @@ -451,7 +451,7 @@ INT#_C macros if they're not already defined (John Maddock). #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(value##u) # else diff --git a/3rdparty/boost/boost/describe/bases.hpp b/3rdparty/boost/boost/describe/bases.hpp new file mode 100644 index 0000000000..b01313e046 --- /dev/null +++ b/3rdparty/boost/boost/describe/bases.hpp @@ -0,0 +1,50 @@ +#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 +#include +#include + +#if defined(BOOST_DESCRIBE_CXX11) + +#include +#include + +namespace boost +{ +namespace describe +{ +namespace detail +{ + +template using _describe_bases = decltype( boost_base_descriptor_fn( static_cast(0) ) ); + +template struct base_filter +{ + template using fn = mp11::mp_bool< ( M & mod_any_access & T::modifiers ) != 0 >; +}; + +template struct has_describe_bases: std::false_type +{ +}; + +template struct has_describe_bases>>: std::true_type +{ +}; + +} // namespace detail + +template using describe_bases = mp11::mp_copy_if_q, detail::base_filter>; + +template using has_describe_bases = detail::has_describe_bases; + +} // namespace describe +} // namespace boost + +#endif // !defined(BOOST_DESCRIBE_CXX11) + +#endif // #ifndef BOOST_DESCRIBE_BASES_HPP_INCLUDED diff --git a/3rdparty/boost/boost/describe/detail/config.hpp b/3rdparty/boost/boost/describe/detail/config.hpp new file mode 100644 index 0000000000..c24a070e32 --- /dev/null +++ b/3rdparty/boost/boost/describe/detail/config.hpp @@ -0,0 +1,40 @@ +#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 diff --git a/3rdparty/boost/boost/describe/detail/cx_streq.hpp b/3rdparty/boost/boost/describe/detail/cx_streq.hpp new file mode 100644 index 0000000000..15e87dc270 --- /dev/null +++ b/3rdparty/boost/boost/describe/detail/cx_streq.hpp @@ -0,0 +1,30 @@ +#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 + +#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 diff --git a/3rdparty/boost/boost/describe/detail/void_t.hpp b/3rdparty/boost/boost/describe/detail/void_t.hpp new file mode 100644 index 0000000000..f304250d85 --- /dev/null +++ b/3rdparty/boost/boost/describe/detail/void_t.hpp @@ -0,0 +1,32 @@ +#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 + +#if defined(BOOST_DESCRIBE_CXX11) + +namespace boost +{ +namespace describe +{ +namespace detail +{ + +template struct make_void +{ + using type = void; +}; + +template using void_t = typename make_void::type; + +} // namespace detail +} // namespace describe +} // namespace boost + +#endif // defined(BOOST_DESCRIBE_CXX11) + +#endif // #ifndef BOOST_DESCRIBE_DETAIL_VOID_T_HPP_INCLUDED diff --git a/3rdparty/boost/boost/describe/members.hpp b/3rdparty/boost/boost/describe/members.hpp new file mode 100644 index 0000000000..bce49db77d --- /dev/null +++ b/3rdparty/boost/boost/describe/members.hpp @@ -0,0 +1,159 @@ +#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 +#include +#include +#include +#include + +#if defined(BOOST_DESCRIBE_CXX11) + +#include +#include +#include +#include +#include +#include + +namespace boost +{ +namespace describe +{ +namespace detail +{ + +// _describe_members + +template using _describe_public_members = decltype( boost_public_member_descriptor_fn( static_cast(0) ) ); +template using _describe_protected_members = decltype( boost_protected_member_descriptor_fn( static_cast(0) ) ); +template using _describe_private_members = decltype( boost_private_member_descriptor_fn( static_cast(0) ) ); + +template using _describe_members = mp11::mp_append<_describe_public_members, _describe_protected_members, _describe_private_members>; + +// describe_inherited_members + +// T: type +// V: list of virtual bases visited so far +template struct describe_inherited_members_impl; +template using describe_inherited_members = typename describe_inherited_members_impl::type; + +// L: list of base class descriptors +// T: derived type +// V: list of virtual bases visited so far +template struct describe_inherited_members2_impl; +template using describe_inherited_members2 = typename describe_inherited_members2_impl::type; + +template struct describe_inherited_members_impl +{ + using R1 = describe_inherited_members2, T, V>; + using R2 = _describe_members; + + using type = mp11::mp_append; +}; + +template class L, class T, class V> struct describe_inherited_members2_impl, T, V> +{ + using type = L<>; +}; + +template using name_matches = mp11::mp_bool< cx_streq( D1::name, D2::name ) >; + +template using name_is_hidden = mp11::mp_any_of_q>; + +constexpr unsigned cx_max( unsigned m1, unsigned m2 ) +{ + return m1 > m2? m1: m2; +} + +template struct update_modifiers +{ + template struct fn + { + using L = _describe_members; + static constexpr unsigned hidden = name_is_hidden::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 template constexpr decltype(D::pointer) update_modifiers::fn::pointer; +template template constexpr decltype(D::name) update_modifiers::fn::name; +template template constexpr unsigned update_modifiers::fn::modifiers; + +template struct gather_virtual_bases_impl; +template using gather_virtual_bases = typename gather_virtual_bases_impl::type; + +template struct gather_virtual_bases_impl +{ + using B = typename D::type; + static constexpr unsigned M = D::modifiers; + + using R1 = mp11::mp_transform>; + using R2 = mp11::mp_apply; + + using type = mp11::mp_if_c<(M & mod_virtual) != 0, mp11::mp_push_front, R2>; +}; + +template class L, class D1, class... D, class T, class V> struct describe_inherited_members2_impl, 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::value, L<>, describe_inherited_members>; + + using R2 = mp11::mp_transform_q, R1>; + + using V2 = mp11::mp_append>; + using R3 = describe_inherited_members2, T, V2>; + + using type = mp11::mp_append; +}; + +// describe_members + +template using describe_members = mp11::mp_eval_if_c<(M & mod_inherited) == 0, _describe_members, describe_inherited_members, T, mp11::mp_list<>>; + +// member_filter + +template struct member_filter +{ + template 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 struct has_describe_members: std::false_type +{ +}; + +template struct has_describe_members>>: std::true_type +{ +}; + +} // namespace detail + +template using describe_members = mp11::mp_copy_if_q, detail::member_filter>; + +template using has_describe_members = detail::has_describe_members; + +} // namespace describe +} // namespace boost + +#endif // !defined(BOOST_DESCRIBE_CXX11) + +#endif // #ifndef BOOST_DESCRIBE_DATA_MEMBERS_HPP_INCLUDED diff --git a/3rdparty/boost/boost/describe/modifiers.hpp b/3rdparty/boost/boost/describe/modifiers.hpp new file mode 100644 index 0000000000..06650ea1d3 --- /dev/null +++ b/3rdparty/boost/boost/describe/modifiers.hpp @@ -0,0 +1,33 @@ +#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 + +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( mod_public | mod_protected | mod_private ); + +} // namespace describe +} // namespace boost + +#endif // #ifndef BOOST_DESCRIBE_MODIFIERS_HPP_INCLUDED diff --git a/3rdparty/boost/boost/detail/container_fwd.hpp b/3rdparty/boost/boost/detail/container_fwd.hpp deleted file mode 100644 index 04ce972738..0000000000 --- a/3rdparty/boost/boost/detail/container_fwd.hpp +++ /dev/null @@ -1,157 +0,0 @@ - -// 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 -#include - -//////////////////////////////////////////////////////////////////////////////// -// // -// 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 -#include -#include -#include -#include -#include -#include -#include - -#else - -#include - -#if defined(BOOST_CONTAINER_FWD_BAD_DEQUE) -#include -#endif - -#if defined(BOOST_CONTAINER_FWD_BAD_BITSET) -#include -#endif - -#if defined(BOOST_MSVC) -#pragma warning(push) -#pragma warning(disable:4099) // struct/class mismatch in fwd declarations -#endif - -namespace std -{ - template class allocator; - template class basic_string; - - template struct char_traits; - -#if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT) - template struct complex; -#else - template class complex; -#endif - -#if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE) - template class deque; -#endif - - template class list; - template class vector; - template class map; - template - class multimap; - template class set; - template class multiset; - -#if !defined(BOOST_CONTAINER_FWD_BAD_BITSET) - template class bitset; -#endif - template 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 diff --git a/3rdparty/boost/boost/detail/iterator.hpp b/3rdparty/boost/boost/detail/iterator.hpp deleted file mode 100644 index 2498ef448f..0000000000 --- a/3rdparty/boost/boost/detail/iterator.hpp +++ /dev/null @@ -1,39 +0,0 @@ -// (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 -#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) -#include -#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_ diff --git a/3rdparty/boost/boost/detail/workaround.hpp b/3rdparty/boost/boost/detail/workaround.hpp index fb96115880..9c392182a0 100644 --- a/3rdparty/boost/boost/detail/workaround.hpp +++ b/3rdparty/boost/boost/detail/workaround.hpp @@ -2,9 +2,9 @@ // 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 -#endif // WORKAROUND_DWA2002126_HPP +#endif // BOOST_WORKAROUND_DWA2002126_HPP diff --git a/3rdparty/boost/boost/exception/exception.hpp b/3rdparty/boost/boost/exception/exception.hpp index 5fe3009290..ca8d83359a 100644 --- a/3rdparty/boost/boost/exception/exception.hpp +++ b/3rdparty/boost/boost/exception/exception.hpp @@ -3,10 +3,12 @@ //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 #include +#include #ifdef BOOST_EXCEPTION_MINI_BOOST #include @@ -16,13 +18,18 @@ namespace boost { template class shared_ptr; } 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 @@ -101,6 +108,7 @@ boost typedef error_info throw_function; typedef error_info throw_file; typedef error_info throw_line; + typedef error_info throw_column; template <> class @@ -144,6 +152,20 @@ boost } }; + template <> + class + error_info + { + public: + typedef int value_type; + value_type v_; + explicit + error_info( value_type v ): + v_(v) + { + } + }; + class BOOST_SYMBOL_VISIBLE exception; @@ -183,6 +205,9 @@ boost template <> struct get_info; + template <> + struct get_info; + template struct set_info_rv; @@ -195,6 +220,9 @@ boost template <> struct set_info_rv; + template <> + struct set_info_rv; + char const * get_diagnostic_information( exception const &, char const * ); void copy_boost_exception( exception *, exception const * ); @@ -210,6 +238,11 @@ boost template E const & set_info( E const &, throw_line const & ); + + template + E const & set_info( E const &, throw_column const & ); + + boost::source_location get_exception_throw_location( exception const & ); } class @@ -227,7 +260,8 @@ boost exception(): throw_function_(0), throw_file_(0), - throw_line_(-1) + throw_line_(-1), + throw_column_(-1) { } @@ -238,7 +272,8 @@ boost 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 @@ -263,27 +298,35 @@ boost template friend E const & exception_detail::set_info( E const &, throw_line const & ); + template + friend E const & exception_detail::set_info( E const &, throw_column const & ); + template friend E const & exception_detail::set_info( E const &, error_info 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 friend struct exception_detail::get_info; friend struct exception_detail::get_info; friend struct exception_detail::get_info; friend struct exception_detail::get_info; + friend struct exception_detail::get_info; template friend struct exception_detail::set_info_rv; friend struct exception_detail::set_info_rv; friend struct exception_detail::set_info_rv; friend struct exception_detail::set_info_rv; + friend struct exception_detail::set_info_rv; friend void exception_detail::copy_boost_exception( exception *, exception const * ); #endif mutable exception_detail::refcount_ptr data_; mutable char const * throw_function_; mutable char const * throw_file_; mutable int throw_line_; + mutable int throw_column_; }; inline @@ -318,6 +361,42 @@ boost x.throw_line_=y.v_; return x; } + + template + 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 + { + template + 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 + ); + } } //////////////////////////////////////////////////////////////////////// @@ -385,6 +464,9 @@ boost } //////////////////////////////////////////////////////////////////////// +#if defined(BOOST_NO_EXCEPTIONS) + BOOST_NORETURN void throw_exception(std::exception const & e); // user defined +#endif namespace exception_detail @@ -414,6 +496,7 @@ boost 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; } @@ -461,7 +544,11 @@ boost void rethrow() const { +#if defined(BOOST_NO_EXCEPTIONS) + boost::throw_exception(*this); +#else throw*this; +#endif } }; } @@ -473,54 +560,10 @@ boost { return exception_detail::clone_impl(x); } - - template - struct - BOOST_SYMBOL_VISIBLE - wrapexcept: - public exception_detail::clone_impl::type> - { - typedef exception_detail::clone_impl::type> base_type; - public: - explicit - wrapexcept( typename exception_detail::enable_error_info_return_type::type const & x ): - base_type( x ) - { - } - - ~wrapexcept() BOOST_NOEXCEPT_OR_NOTHROW - { - } - }; - - namespace - exception_detail - { - template - struct - remove_error_info_injector - { - typedef T type; - }; - - template - struct - remove_error_info_injector< error_info_injector > - { - typedef T type; - }; - - template - inline - wrapexcept::type> - enable_both( T const & x ) - { - return wrapexcept::type>( enable_error_info( x ) ); - } - } } #if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) #pragma warning(pop) #endif -#endif + +#endif // #ifndef BOOST_EXCEPTION_274DA366004E11DCB1DDFE2E56D89593 diff --git a/3rdparty/boost/boost/integer.hpp b/3rdparty/boost/boost/integer.hpp index 9fa0019484..ad7945ac62 100644 --- a/3rdparty/boost/boost/integer.hpp +++ b/3rdparty/boost/boost/integer.hpp @@ -2,9 +2,9 @@ // 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) @@ -137,7 +137,7 @@ namespace boost { 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 + @@ -219,7 +219,7 @@ namespace boost #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 = diff --git a/3rdparty/boost/boost/integer/static_log2.hpp b/3rdparty/boost/boost/integer/static_log2.hpp deleted file mode 100644 index 56c7a00125..0000000000 --- a/3rdparty/boost/boost/integer/static_log2.hpp +++ /dev/null @@ -1,127 +0,0 @@ -// -------------- 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 - 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::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 - 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 - // ---------------------------------------- - - template - struct static_log2 { - - BOOST_STATIC_CONSTANT( - static_log2_result_type, - value = detail::static_log2_impl::static_log2_impl::value - ); - - }; - - - template <> - struct static_log2<0> { }; - -} - - - -#endif // include guard diff --git a/3rdparty/boost/boost/integer_fwd.hpp b/3rdparty/boost/boost/integer_fwd.hpp index 18519dd696..6eac5aafb4 100644 --- a/3rdparty/boost/boost/integer_fwd.hpp +++ b/3rdparty/boost/boost/integer_fwd.hpp @@ -2,9 +2,9 @@ // (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 diff --git a/3rdparty/boost/boost/integer_traits.hpp b/3rdparty/boost/boost/integer_traits.hpp index 94eb00d31e..c2d4897a65 100644 --- a/3rdparty/boost/boost/integer_traits.hpp +++ b/3rdparty/boost/boost/integer_traits.hpp @@ -3,14 +3,14 @@ * 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 @@ -103,7 +103,7 @@ class integer_traits // library: they are wrong! #if defined(WCHAR_MIN) && defined(WCHAR_MAX) && !defined(__APPLE__) public detail::integer_traits_base -#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 #elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\ diff --git a/3rdparty/boost/boost/mp11/algorithm.hpp b/3rdparty/boost/boost/mp11/algorithm.hpp new file mode 100644 index 0000000000..06c8e48997 --- /dev/null +++ b/3rdparty/boost/boost/mp11/algorithm.hpp @@ -0,0 +1,1306 @@ +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_transform +namespace detail +{ + +template class F, class... L> struct mp_transform_impl +{ +}; + +template class F, template class L, class... T> struct mp_transform_impl> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + + template struct f { using type = F; }; + + using type = L::type...>; + +#else + + using type = L...>; + +#endif +}; + +template class F, template class L1, class... T1, template class L2, class... T2> struct mp_transform_impl, L2> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + + template struct f { using type = F; }; + + using type = L1::type...>; + +#else + + using type = L1...>; + +#endif +}; + +template class F, template class L1, class... T1, template class L2, class... T2, template class L3, class... T3> struct mp_transform_impl, L2, L3> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + + template struct f { using type = F; }; + + using type = L1::type...>; + +#else + + using type = L1...>; + +#endif +}; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 ) + +template using mp_same_size_1 = mp_same...>; +template struct mp_same_size_2: mp_defer {}; + +#endif + +struct list_size_mismatch +{ +}; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) + +template class F, class... L> struct mp_transform_cuda_workaround +{ + using type = mp_if...>, detail::mp_transform_impl, detail::list_size_mismatch>; +}; + +#endif + +} // namespace detail + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 ) + +template class F, class... L> using mp_transform = typename mp_if::type, detail::mp_transform_impl, detail::list_size_mismatch>::type; + +#else + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) + +template class F, class... L> using mp_transform = typename detail::mp_transform_cuda_workaround< F, L...>::type::type; + +#else + +template class F, class... L> using mp_transform = typename mp_if...>, detail::mp_transform_impl, detail::list_size_mismatch>::type; + +#endif + +#endif + +template using mp_transform_q = mp_transform; + +namespace detail +{ + +template class F, template class L1, class... T1, template class L2, class... T2, template class L3, class... T3, template class L4, class... T4, class... L> struct mp_transform_impl, L2, L3, L4, L...> +{ + using A1 = L1...>; + + template using _f = mp_transform; + + using A2 = mp_fold, A1, _f>; + + template using _g = mp_apply; + + using type = mp_transform<_g, A2>; +}; + +} // namespace detail + +// mp_transform_if +namespace detail +{ + +template class P, template 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

; + using Qf = mp_quote; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + + template struct _f_ { using type = mp_eval_if_q>, mp_first>, Qf, U...>; }; + template using _f = typename _f_::type; + +#else + + template using _f = mp_eval_if_q>, mp_first>, Qf, U...>; + +#endif + + using type = mp_transform<_f, L...>; +}; + +} // namespace detail + +template class P, template class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl::type; +template using mp_transform_if_q = typename detail::mp_transform_if_impl::type; + +// mp_filter +namespace detail +{ + +template class P, class L1, class... L> struct mp_filter_impl +{ + using Qp = mp_quote

; + + template using _f = mp_if< mp_invoke_q, mp_list, mp_list<> >; + + using _t1 = mp_transform<_f, L1, L...>; + using _t2 = mp_apply; + + using type = mp_assign; +}; + +} // namespace detail + +template class P, class... L> using mp_filter = typename detail::mp_filter_impl::type; +template using mp_filter_q = typename detail::mp_filter_impl::type; + +// mp_fill +namespace detail +{ + +template struct mp_fill_impl; + +template class L, class... T, class V> struct mp_fill_impl, V> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 ) + + template struct _f { using type = V; }; + using type = L::type...>; + +#else + + template using _f = V; + using type = L<_f...>; + +#endif +}; + +} // namespace detail + +template using mp_fill = typename detail::mp_fill_impl::type; + +// mp_contains +template using mp_contains = mp_to_bool>; + +// mp_repeat(_c) +namespace detail +{ + +template struct mp_repeat_c_impl +{ + using _l1 = typename mp_repeat_c_impl::type; + using _l2 = typename mp_repeat_c_impl::type; + + using type = mp_append<_l1, _l1, _l2>; +}; + +template struct mp_repeat_c_impl +{ + using type = mp_clear; +}; + +template struct mp_repeat_c_impl +{ + using type = L; +}; + +} // namespace detail + +template using mp_repeat_c = typename detail::mp_repeat_c_impl::type; +template using mp_repeat = typename detail::mp_repeat_c_impl::type; + +// mp_product +namespace detail +{ + +template class F, class P, class... L> struct mp_product_impl_2 +{ +}; + +template class F, class P> struct mp_product_impl_2 +{ + using type = mp_list>; +}; + +template class F, class P, template class L1, class... T1, class... L> struct mp_product_impl_2, L...> +{ + using type = mp_append, L...>::type...>; +}; + +template class F, class... L> struct mp_product_impl +{ +}; + +template class F> struct mp_product_impl +{ + using type = mp_list< F<> >; +}; + +template class F, class L1, class... L> struct mp_product_impl +{ + using type = mp_assign, L1, L...>::type>; +}; + +} // namespace detail + +template class F, class... L> using mp_product = typename detail::mp_product_impl::type; +template using mp_product_q = typename detail::mp_product_impl::type; + +// mp_drop(_c) +namespace detail +{ + +template struct mp_drop_impl; + +template class L, class... T, template class L2, class... U> struct mp_drop_impl, L2> +{ + template static mp_identity> f( U*..., mp_identity*... ); + + using R = decltype( f( (mp_identity*)0 ... ) ); + + using type = typename R::type; +}; + +} // namespace detail + +template using mp_drop_c = typename detail::mp_drop_impl, N>>::type; + +template using mp_drop = typename detail::mp_drop_impl, N>>::type; + +// mp_from_sequence +namespace detail +{ + +template struct mp_from_sequence_impl; + +template class S, class U, U... J> struct mp_from_sequence_impl> +{ + using type = mp_list...>; +}; + +} // namespace detail + +template using mp_from_sequence = typename detail::mp_from_sequence_impl::type; + +// mp_iota(_c) +template using mp_iota_c = mp_from_sequence>; +template using mp_iota = mp_from_sequence::type, N::value>>; + +// mp_at(_c) +namespace detail +{ + +template struct mp_at_c_impl; + +#if defined(BOOST_MP11_HAS_TYPE_PACK_ELEMENT) + +template class L, class... T, std::size_t I> struct mp_at_c_impl, I> +{ + using type = __type_pack_element; +}; + +#else + +template struct mp_at_c_impl +{ + using _map = mp_transform >, L>; + using type = mp_second > >; +}; + +#endif + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) + +template struct mp_at_c_cuda_workaround +{ + using type = mp_if_c<(I < mp_size::value), detail::mp_at_c_impl, void>; +}; + +#endif + +} // namespace detail + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) + +template using mp_at_c = typename detail::mp_at_c_cuda_workaround< L, I >::type::type; + +#else + +template using mp_at_c = typename mp_if_c<(I < mp_size::value), detail::mp_at_c_impl, void>::type; + +#endif + +template using mp_at = mp_at_c; + +// mp_take(_c) +namespace detail +{ + +template struct mp_take_c_impl +{ +}; + +template class L, class... T> +struct mp_take_c_impl<0, L> +{ + using type = L<>; +}; + +template class L, class T1, class... T> +struct mp_take_c_impl<1, L> +{ + using type = L; +}; + +template class L, class T1, class T2, class... T> +struct mp_take_c_impl<2, L> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class... T> +struct mp_take_c_impl<3, L> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4, class... T> +struct mp_take_c_impl<4, L> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4, class T5, class... T> +struct mp_take_c_impl<5, L> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4, class T5, class T6, class... T> +struct mp_take_c_impl<6, L> +{ + using type = L; +}; + +template 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> +{ + using type = L; +}; + +template 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> +{ + using type = L; +}; + +template 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> +{ + using type = L; +}; + +template 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, typename std::enable_if= 10>::type> +{ + using type = mp_append, typename mp_take_c_impl>::type>; +}; + +} // namespace detail + +template using mp_take_c = typename detail::mp_take_c_impl::type; +template using mp_take = typename detail::mp_take_c_impl::type; + +// mp_back +template using mp_back = mp_at_c::value - 1>; + +// mp_pop_back +template using mp_pop_back = mp_take_c::value - 1>; + +// mp_replace +namespace detail +{ + +template struct mp_replace_impl; + +template class L, class... T, class V, class W> struct mp_replace_impl, V, W> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + template struct _f { using type = mp_if, W, A>; }; + using type = L::type...>; +#else + template using _f = mp_if, W, A>; + using type = L<_f...>; +#endif +}; + +} // namespace detail + +template using mp_replace = typename detail::mp_replace_impl::type; + +// mp_replace_if +namespace detail +{ + +template class P, class W> struct mp_replace_if_impl; + +template class L, class... T, template class P, class W> struct mp_replace_if_impl, P, W> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + template struct _f { using type = mp_if, W, U>; }; + using type = L::type...>; +#else + template using _f = mp_if, W, U>; + using type = L<_f...>; +#endif +}; + +} // namespace detail + +template class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl::type; +template using mp_replace_if_q = mp_replace_if; + +// mp_copy_if +// in detail/mp_copy_if.hpp + +// mp_remove +namespace detail +{ + +template struct mp_remove_impl; + +template class L, class... T, class V> struct mp_remove_impl, V> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + template struct _f { using type = mp_if, mp_list<>, mp_list>; }; + using type = mp_append, typename _f::type...>; +#else + template using _f = mp_if, mp_list<>, mp_list>; + using type = mp_append, _f...>; +#endif +}; + +} // namespace detail + +template using mp_remove = typename detail::mp_remove_impl::type; + +// mp_remove_if +// in detail/mp_remove_if.hpp + +// mp_flatten> +namespace detail +{ + +template struct mp_flatten_impl +{ + template using fn = mp_if, T, mp_list>; +}; + +} // namespace detail + +template> using mp_flatten = mp_apply, L>, mp_clear>>; + +// mp_partition +namespace detail +{ + +template class P> struct mp_partition_impl; + +template class L, class... T, template class P> struct mp_partition_impl, P> +{ + using type = L, P>, mp_remove_if, P>>; +}; + +} // namespace detail + +template class P> using mp_partition = typename detail::mp_partition_impl::type; +template using mp_partition_q = mp_partition; + +// mp_sort +namespace detail +{ + +template class P> struct mp_sort_impl; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + +template class L, class... T, template class P> struct mp_sort_impl, P> +{ + static_assert( sizeof...(T) == 0, "T... must be empty" ); + using type = L<>; +}; + +#else + +template class L, template class P> struct mp_sort_impl, P> +{ + using type = L<>; +}; + +#endif + +template class L, class T1, template class P> struct mp_sort_impl, P> +{ + using type = L; +}; + +template class L, class T1, class... T, template class P> struct mp_sort_impl, P> +{ + template using F = P; + + using part = mp_partition, F>; + + using S1 = typename mp_sort_impl, P>::type; + using S2 = typename mp_sort_impl, P>::type; + + using type = mp_append, S2>; +}; + +} // namespace detail + +template class P> using mp_sort = typename detail::mp_sort_impl::type; +template using mp_sort_q = mp_sort; + +// mp_nth_element(_c) +namespace detail +{ + +template class P> struct mp_nth_element_impl; + +template class L, class T1, std::size_t I, template class P> struct mp_nth_element_impl, I, P> +{ + static_assert( I == 0, "mp_nth_element index out of range" ); + using type = T1; +}; + +template class L, class T1, class... T, std::size_t I, template class P> struct mp_nth_element_impl, I, P> +{ + static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" ); + + template using F = P; + + using part = mp_partition, F>; + + using L1 = mp_first; + static std::size_t const N1 = mp_size::value; + + using L2 = mp_second; + +#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, + mp_bool<(I == N1)>, mp_identity, + mp_true, mp_nth_element_impl + + >; + }; + }; + + 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, + mp_bool<(I == N1)>, mp_identity, + mp_true, mp_nth_element_impl + + >::type; + +#endif +}; + +} // namespace detail + +template class P> using mp_nth_element_c = typename detail::mp_nth_element_impl::type; +template class P> using mp_nth_element = typename detail::mp_nth_element_impl::type; +template using mp_nth_element_q = mp_nth_element; + +// mp_find +namespace detail +{ + +template 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 class L, class... T, class V> struct mp_find_impl, V> +{ + static constexpr mp_index_holder _v{ 0, false }; + using type = mp_size_t< (_v + ... + std::is_same::value).i_ >; +}; + +#elif !defined( BOOST_MP11_NO_CONSTEXPR ) + +template class L, class V> struct mp_find_impl, 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 class L, class... T, class V> struct mp_find_impl, V> +{ + static constexpr bool _v[] = { std::is_same::value... }; + using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >; +}; + +#else + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + +template class L, class... T, class V> struct mp_find_impl, V> +{ + static_assert( sizeof...(T) == 0, "T... must be empty" ); + using type = mp_size_t<0>; +}; + +#else + +template class L, class V> struct mp_find_impl, V> +{ + using type = mp_size_t<0>; +}; + +#endif + +template class L, class... T, class V> struct mp_find_impl, V> +{ + using type = mp_size_t<0>; +}; + +template class L, class T1, class... T, class V> struct mp_find_impl, V> +{ + using _r = typename mp_find_impl, V>::type; + using type = mp_size_t<1 + _r::value>; +}; + +#endif + +} // namespace detail + +template using mp_find = typename detail::mp_find_impl::type; + +// mp_find_if +namespace detail +{ + +template class P> struct mp_find_if_impl; + +#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS ) + +template class L, class... T, template class P> struct mp_find_if_impl, P> +{ + static constexpr mp_index_holder _v{ 0, false }; + using type = mp_size_t< (_v + ... + P::value).i_ >; +}; + +#elif !defined( BOOST_MP11_NO_CONSTEXPR ) + +template class L, template class P> struct mp_find_if_impl, P> +{ + using type = mp_size_t<0>; +}; + +template class L, class... T, template class P> struct mp_find_if_impl, P> +{ + static constexpr bool _v[] = { P::value... }; + using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >; +}; + +#else + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + +template class L, class... T, template class P> struct mp_find_if_impl, P> +{ + static_assert( sizeof...(T) == 0, "T... must be empty" ); + using type = mp_size_t<0>; +}; + +#else + +template class L, template class P> struct mp_find_if_impl, P> +{ + using type = mp_size_t<0>; +}; + +#endif + +template class P> struct mp_find_if_impl_2 +{ + using _r = typename mp_find_if_impl::type; + using type = mp_size_t<1 + _r::value>; +}; + +template class L, class T1, class... T, template class P> struct mp_find_if_impl, P> +{ + using type = typename mp_if, mp_identity>, mp_find_if_impl_2, P>>::type; +}; + +#endif + +} // namespace detail + +template class P> using mp_find_if = typename detail::mp_find_if_impl::type; +template using mp_find_if_q = mp_find_if; + +// mp_reverse +namespace detail +{ + +template struct mp_reverse_impl; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + +template class L, class... T> struct mp_reverse_impl> +{ + static_assert( sizeof...(T) == 0, "T... must be empty" ); + using type = L<>; +}; + +#else + +template class L> struct mp_reverse_impl> +{ + using type = L<>; +}; + +#endif + +template class L, class T1> struct mp_reverse_impl> +{ + using type = L; +}; + +template class L, class T1, class T2> struct mp_reverse_impl> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3> struct mp_reverse_impl> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4> struct mp_reverse_impl> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4, class T5> struct mp_reverse_impl> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4, class T5, class T6> struct mp_reverse_impl> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7> struct mp_reverse_impl> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> struct mp_reverse_impl> +{ + using type = L; +}; + +template class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9> struct mp_reverse_impl> +{ + using type = L; +}; + +template 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> +{ + using type = mp_push_back>::type, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1>; +}; + +} // namespace detail + +template using mp_reverse = typename detail::mp_reverse_impl::type; + +// mp_fold +// in detail/mp_fold.hpp + +// mp_reverse_fold +namespace detail +{ + +template class F> struct mp_reverse_fold_impl; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + +template class L, class... T, class V, template class F> struct mp_reverse_fold_impl, V, F> +{ + static_assert( sizeof...(T) == 0, "T... must be empty" ); + using type = V; +}; + +#else + +template class L, class V, template class F> struct mp_reverse_fold_impl, V, F> +{ + using type = V; +}; + +#endif + +template class L, class T1, class... T, class V, template class F> struct mp_reverse_fold_impl, V, F> +{ + using rest = typename mp_reverse_fold_impl, V, F>::type; + using type = F; +}; + +template 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 F> struct mp_reverse_fold_impl, V, F> +{ + using rest = typename mp_reverse_fold_impl, V, F>::type; + using type = F > > > > > > > > >; +}; + +} // namespace detail + +template class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl::type; +template using mp_reverse_fold_q = mp_reverse_fold; + +// mp_unique +namespace detail +{ + +template struct mp_unique_impl; + +template class L, class... T> struct mp_unique_impl> +{ + using type = mp_set_push_back, T...>; +}; + +} // namespace detail + +template using mp_unique = typename detail::mp_unique_impl::type; + +// mp_unique_if +namespace detail +{ + +template class P> struct mp_unique_if_push_back +{ + template struct impl + { + }; + + template class L, class... Ts, class T> + struct impl, T> + { + using type = mp_if...>, L, L>; + }; + + template using fn = typename impl::type; +}; + +} // namespace detail + +template class P> +using mp_unique_if = mp_fold_q, detail::mp_unique_if_push_back

>; + +template using mp_unique_if_q = mp_unique_if; + +// mp_all_of +template class P> using mp_all_of = mp_bool< mp_count_if::value == mp_size::value >; +template using mp_all_of_q = mp_all_of; + +// mp_none_of +template class P> using mp_none_of = mp_bool< mp_count_if::value == 0 >; +template using mp_none_of_q = mp_none_of; + +// mp_any_of +template class P> using mp_any_of = mp_bool< mp_count_if::value != 0 >; +template using mp_any_of_q = mp_any_of; + +// mp_replace_at_c +namespace detail +{ + +template struct mp_replace_at_impl +{ + static_assert( I::value >= 0, "mp_replace_at: I must not be negative" ); + + template using _p = std::is_same>; + template using _f = W; + + using type = mp_transform_if<_p, _f, L, mp_iota > >; +}; + +} // namespace detail + +template using mp_replace_at = typename detail::mp_replace_at_impl::type; +template using mp_replace_at_c = typename detail::mp_replace_at_impl, W>::type; + +//mp_for_each(f) +namespace detail +{ + +template BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list, F && f ) +{ + using A = int[sizeof...(T)]; + return (void)A{ ((void)f(T()), 0)... }, std::forward(f); +} + +template BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f ) +{ + return std::forward(f); +} + +} // namespace detail + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, >= 1900 ) + +// msvc has a limit of 1024 + +template BOOST_MP11_CONSTEXPR mp_if_c::value <= 1024, F> mp_for_each( F && f ) +{ + return detail::mp_for_each_impl( mp_rename(), std::forward(f) ); +} + +template BOOST_MP11_CONSTEXPR mp_if_c::value >= 1025, F> mp_for_each( F && f ) +{ + using L2 = mp_rename; + + using L3 = mp_take_c; + using L4 = mp_drop_c; + + return mp_for_each( mp_for_each( std::forward(f) ) ); +} + +#else + +template BOOST_MP11_CONSTEXPR F mp_for_each( F && f ) +{ + return detail::mp_for_each_impl( mp_rename(), std::forward(f) ); +} + +#endif + +// mp_insert +template using mp_insert = mp_append, mp_push_front, T...>>; + +// mp_insert_c +template using mp_insert_c = mp_append, mp_push_front, T...>>; + +// mp_erase +template using mp_erase = mp_append, mp_drop>; + +// mp_erase_c +template using mp_erase_c = mp_append, mp_drop_c>; + +// mp_starts_with +// contributed by Glen Joseph Fernandes (glenjofe@gmail.com) +namespace detail { + +template +struct mp_starts_with_impl { }; + +template class L1, class... T1, template class L2, + class... T2> +struct mp_starts_with_impl, L2 > { + template + static mp_false check(L); + + template + static mp_true check(mp_list); + + using type = decltype(check(mp_list())); +}; + +} // namespace detail + +template +using mp_starts_with = typename detail::mp_starts_with_impl::type; + +// mp_rotate_left(_c) +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 using canonical_left_rotation = mp_size_t; + +// perform right rotation as a left rotation by inverting the number of elements to rotate +template using canonical_right_rotation = mp_size_t; + +// avoid errors when rotating fixed-sized lists by using mp_list for the transformation +template> using mp_rotate_impl = mp_assign, mp_take >>; + +} // namespace detail + +template using mp_rotate_left_c = detail::mp_rotate_impl::value, N>>; +template using mp_rotate_left = mp_rotate_left_c; + +// mp_rotate_right(_c) +template using mp_rotate_right_c = mp_rotate_left::value, N>>; +template using mp_rotate_right = mp_rotate_right_c; + +// mp_min_element +// mp_max_element +// in detail/mp_min_element.hpp + +// mp_power_set +namespace detail +{ + +template struct mp_power_set_impl; + +} // namespace detail + +template using mp_power_set = typename detail::mp_power_set_impl::type; + +namespace detail +{ + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + +template class L, class... T> struct mp_power_set_impl< L > +{ + static_assert( sizeof...(T) == 0, "T... must be empty" ); + using type = L< L<> >; +}; + +#else + +template class L> struct mp_power_set_impl< L<> > +{ + using type = L< L<> >; +}; + +#endif + +template class L, class T1, class... T> struct mp_power_set_impl< L > +{ + using S1 = mp_power_set< L >; + + template using _f = mp_push_front; + + using S2 = mp_transform<_f, S1>; + + using type = mp_append< S1, S2 >; +}; + +} // namespace detail + +// mp_partial_sum +namespace detail +{ + +template class F> struct mp_partial_sum_impl_f +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 ) + + template using fn = mp_list, T>, mp_push_back, F, T>> >; + +#else + + template, T>> using fn = mp_list, N>>; + +#endif +}; + +} // namespace detail + +template class F> using mp_partial_sum = mp_second>, detail::mp_partial_sum_impl_f> >; +template using mp_partial_sum_q = mp_partial_sum; + +// mp_iterate +namespace detail +{ + +template class F, template class R, class N> struct mp_iterate_impl; + +} // namespace detail + +template class F, template class R> using mp_iterate = typename detail::mp_iterate_impl>::type; + +namespace detail +{ + +template class F, template class R> struct mp_iterate_impl +{ + template using _f = mp_list>; + using type = mp_eval_or, _f, V>; +}; + +template class F, template class R> struct mp_iterate_impl +{ + using type = mp_push_front, F, R>, F>; +}; + +} // namespace detail + +template using mp_iterate_q = mp_iterate; + +// mp_pairwise_fold +namespace detail +{ + +template using mp_pairwise_fold_impl = mp_transform_q, mp_pop_front>; + +} // namespace detail + +template using mp_pairwise_fold_q = mp_eval_if, mp_clear, detail::mp_pairwise_fold_impl, L, Q>; +template class F> using mp_pairwise_fold = mp_pairwise_fold_q>; + +// mp_intersperse +namespace detail +{ + +template struct mp_intersperse_impl +{ +}; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + +template class L, class... T, class S> struct mp_intersperse_impl, S> +{ + static_assert( sizeof...(T) == 0, "T... must be empty" ); + using type = L<>; +}; + +#else + +template class L, class S> struct mp_intersperse_impl, S> +{ + using type = L<>; +}; + +#endif + +template class L, class T1, class... T, class S> struct mp_intersperse_impl, S> +{ + using type = mp_append, L...>; +}; + +} // namespace detail + +template using mp_intersperse = typename detail::mp_intersperse_impl::type; + +// mp_split +namespace detail +{ + +template struct mp_split_impl; + +} // namespace detail + +template using mp_split = typename detail::mp_split_impl>::type; + +namespace detail +{ + +template using mp_split_impl_ = mp_push_front, S>, mp_take>; + +template struct mp_split_impl +{ + using type = mp_eval_if_c::value == J::value, mp_push_back, L>, mp_split_impl_, L, S, J>; +}; + +} // namespace detail + +// mp_join + +template using mp_join = mp_apply>>; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/bind.hpp b/3rdparty/boost/boost/mp11/bind.hpp new file mode 100644 index 0000000000..bbdecd2208 --- /dev/null +++ b/3rdparty/boost/boost/mp11/bind.hpp @@ -0,0 +1,111 @@ +#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 +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_bind_front +template 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 using fn = typename mp_defer::type; +}; + +template using mp_bind_front_q = mp_bind_front; + +// mp_bind_back +template class F, class... T> struct mp_bind_back +{ + template using fn = typename mp_defer::type; +}; + +template using mp_bind_back_q = mp_bind_back; + +// mp_arg +template struct mp_arg +{ + template using fn = mp_at_c, 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 class F, class... T> struct mp_bind; + +namespace detail +{ + +template struct eval_bound_arg +{ + using type = V; +}; + +template struct eval_bound_arg, T...> +{ + using type = typename mp_arg::template fn; +}; + +template class F, class... U, class... T> struct eval_bound_arg, T...> +{ + using type = typename mp_bind::template fn; +}; + +template class F, class... U, class... T> struct eval_bound_arg, T...> +{ + using type = typename mp_bind_front::template fn; +}; + +template class F, class... U, class... T> struct eval_bound_arg, T...> +{ + using type = typename mp_bind_back::template fn; +}; + +} // namespace detail + +template class F, class... T> struct mp_bind +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1915 ) +private: + + template struct _f { using type = F::type...>; }; + +public: + + template using fn = typename _f::type; + +#else + + template using fn = F::type...>; + +#endif +}; + +template using mp_bind_q = mp_bind; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_BIND_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/config.hpp b/3rdparty/boost/boost/mp11/detail/config.hpp new file mode 100644 index 0000000000..764bd598da --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/config.hpp @@ -0,0 +1,138 @@ +#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() + +// 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 diff --git a/3rdparty/boost/boost/mp11/detail/mp_append.hpp b/3rdparty/boost/boost/mp11/detail/mp_append.hpp new file mode 100644 index 0000000000..937d15ebe4 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_append.hpp @@ -0,0 +1,185 @@ +#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 +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_append + +namespace detail +{ + +template struct mp_append_impl; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 ) + +template struct mp_append_impl +{ +}; + +template<> struct mp_append_impl<> +{ + using type = mp_list<>; +}; + +template class L, class... T> struct mp_append_impl> +{ + using type = L; +}; + +template class L1, class... T1, template class L2, class... T2> struct mp_append_impl, L2> +{ + using type = L1; +}; + +template class L1, class... T1, template class L2, class... T2, template class L3, class... T3> struct mp_append_impl, L2, L3> +{ + using type = L1; +}; + +template class L1, class... T1, template class L2, class... T2, template class L3, class... T3, template class L4, class... T4> struct mp_append_impl, L2, L3, L4> +{ + using type = L1; +}; + +template class L1, class... T1, template class L2, class... T2, template class L3, class... T3, template class L4, class... T4, template class L5, class... T5, class... Lr> struct mp_append_impl, L2, L3, L4, L5, Lr...> +{ + using type = typename mp_append_impl, Lr...>::type; +}; + +#else + +template, 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 L1, class... T1, + template class L2, class... T2, + template class L3, class... T3, + template class L4, class... T4, + template class L5, class... T5, + template class L6, class... T6, + template class L7, class... T7, + template class L8, class... T8, + template class L9, class... T9, + template class L10, class... T10, + template class L11, class... T11> + +struct append_11_impl, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11> +{ + using type = L1; +}; + +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::type, + typename append_11_impl, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19>::type, + typename append_11_impl, L20, L21, L22, L23, L24, L25, L26, L27, L28, L29>::type, + typename append_11_impl, L30, L31, L32, L33, L34, L35, L36, L37, L38, L39>::type, + typename append_11_impl, L40, L41, L42, L43, L44, L45, L46, L47, L48, L49>::type, + typename append_11_impl, L50, L51, L52, L53, L54, L55, L56, L57, L58, L59>::type, + typename append_11_impl, L60, L61, L62, L63, L64, L65, L66, L67, L68, L69>::type, + typename append_11_impl, L70, L71, L72, L73, L74, L75, L76, L77, L78, L79>::type, + typename append_11_impl, L80, L81, L82, L83, L84, L85, L86, L87, L88, L89>::type, + typename append_11_impl, L90, L91, L92, L93, L94, L95, L96, L97, L98, L99>::type, + typename append_11_impl, 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::type; +}; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) + +template +struct mp_append_impl_cuda_workaround +{ + using type = mp_if_c<(sizeof...(L) > 111), mp_quote, mp_if_c<(sizeof...(L) > 11), mp_quote, mp_quote > >; +}; + +template struct mp_append_impl: mp_append_impl_cuda_workaround::type::template fn +{ +}; + +#else + +template struct mp_append_impl: mp_if_c<(sizeof...(L) > 111), mp_quote, mp_if_c<(sizeof...(L) > 11), mp_quote, mp_quote > >::template fn +{ +}; + +#endif + +#endif + +} // namespace detail + +template using mp_append = typename detail::mp_append_impl::type; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_APPEND_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_copy_if.hpp b/3rdparty/boost/boost/mp11/detail/mp_copy_if.hpp new file mode 100644 index 0000000000..4edcde090f --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_copy_if.hpp @@ -0,0 +1,48 @@ +#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 +#include +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_copy_if +namespace detail +{ + +template class P> struct mp_copy_if_impl +{ +}; + +template class L, class... T, template class P> struct mp_copy_if_impl, P> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + template struct _f { using type = mp_if, mp_list, mp_list<>>; }; + using type = mp_append, typename _f::type...>; +#else + template using _f = mp_if, mp_list, mp_list<>>; + using type = mp_append, _f...>; +#endif +}; + +} // namespace detail + +template class P> using mp_copy_if = typename detail::mp_copy_if_impl::type; +template using mp_copy_if_q = mp_copy_if; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_COPY_IF_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_count.hpp b/3rdparty/boost/boost/mp11/detail/mp_count.hpp new file mode 100644 index 0000000000..37b39ed547 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_count.hpp @@ -0,0 +1,147 @@ +#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 +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_count +namespace detail +{ + +#if !defined( BOOST_MP11_NO_CONSTEXPR ) + +constexpr std::size_t cx_plus() +{ + return 0; +} + +template constexpr std::size_t cx_plus(T1 t1, T... t) +{ + return static_cast(t1) + cx_plus(t...); +} + +template +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(t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8 + t9 + t10) + cx_plus(t...); +} + +#endif + +template struct mp_count_impl; + +#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR ) + +template constexpr std::size_t cx_count() +{ + constexpr bool a[] = { false, std::is_same::value... }; + + std::size_t r = 0; + + for( std::size_t i = 1; i < sizeof...(T) + 1; ++i ) + { + r += a[ i ]; + } + + return r; +} + +template class L, class... T, class V> struct mp_count_impl, V> +{ + using type = mp_size_t()>; +}; + +#elif !defined( BOOST_MP11_NO_CONSTEXPR ) + +template class L, class... T, class V> struct mp_count_impl, V> +{ + using type = mp_size_t::value...)>; +}; + +#else + +template class L, class... T, class V> struct mp_count_impl, V> +{ + using type = mp_size_t...>::value>; +}; + +#endif + +} // namespace detail + +template using mp_count = typename detail::mp_count_impl::type; + +// mp_count_if +namespace detail +{ + +template class P> struct mp_count_if_impl; + +#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 ) + +template class P, class... T> constexpr std::size_t cx_count_if() +{ + constexpr bool a[] = { false, static_cast( P::value )... }; + + std::size_t r = 0; + + for( std::size_t i = 1; i < sizeof...(T) + 1; ++i ) + { + r += a[ i ]; + } + + return r; +} + +template class L, class... T, template class P> struct mp_count_if_impl, P> +{ + using type = mp_size_t()>; +}; + +#elif !defined( BOOST_MP11_NO_CONSTEXPR ) + +template class L, class... T, template class P> struct mp_count_if_impl, P> +{ + using type = mp_size_t>::value...)>; +}; + +#else + +template class L, class... T, template class P> struct mp_count_if_impl, P> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + + template struct _f { using type = mp_to_bool>; }; + using type = mp_size_t::type...>::value>; + +#else + + using type = mp_size_t>...>::value>; + +#endif +}; + +#endif + +} // namespace detail + +template class P> using mp_count_if = typename detail::mp_count_if_impl::type; +template using mp_count_if_q = mp_count_if; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_COUNT_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_fold.hpp b/3rdparty/boost/boost/mp11/detail/mp_fold.hpp new file mode 100644 index 0000000000..0745e876f6 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_fold.hpp @@ -0,0 +1,62 @@ +#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 + +namespace boost +{ +namespace mp11 +{ + +// mp_fold +namespace detail +{ + +template 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 class L, class... T, class V, template class F> struct mp_fold_impl, V, F> +{ + static_assert( sizeof...(T) == 0, "T... must be empty" ); + using type = V; +}; + +#else + +template class L, class V, template class F> struct mp_fold_impl, V, F> +{ + using type = V; +}; + +#endif + +template class L, class T1, class... T, class V, template class F> struct mp_fold_impl, V, F> +{ + using type = typename mp_fold_impl, F, F>::type; +}; + +template 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 F> struct mp_fold_impl, V, F> +{ + using type = typename mp_fold_impl, F, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>, T10>, F>::type; +}; + +} // namespace detail + +template class F> using mp_fold = typename detail::mp_fold_impl::type; +template using mp_fold_q = mp_fold; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_FOLD_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_front.hpp b/3rdparty/boost/boost/mp11/detail/mp_front.hpp new file mode 100644 index 0000000000..de83d0929b --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_front.hpp @@ -0,0 +1,38 @@ +#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 +namespace detail +{ + +template 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 class L, class T1, class... T> struct mp_front_impl> +{ + using type = T1; +}; + +} // namespace detail + +template using mp_front = typename detail::mp_front_impl::type; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_is_list.hpp b/3rdparty/boost/boost/mp11/detail/mp_is_list.hpp new file mode 100644 index 0000000000..25b378bde4 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_is_list.hpp @@ -0,0 +1,39 @@ +#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 + +namespace boost +{ +namespace mp11 +{ + +// mp_is_list +namespace detail +{ + +template struct mp_is_list_impl +{ + using type = mp_false; +}; + +template class L, class... T> struct mp_is_list_impl> +{ + using type = mp_true; +}; + +} // namespace detail + +template using mp_is_list = typename detail::mp_is_list_impl::type; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_IS_LIST_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_list.hpp b/3rdparty/boost/boost/mp11/detail/mp_list.hpp new file mode 100644 index 0000000000..8e8d3e5e98 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_list.hpp @@ -0,0 +1,24 @@ +#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 +template struct mp_list +{ +}; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_LIST_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_map_find.hpp b/3rdparty/boost/boost/mp11/detail/mp_map_find.hpp new file mode 100644 index 0000000000..5ba58a44f2 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_map_find.hpp @@ -0,0 +1,87 @@ +#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 +#include + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 ) + +// not exactly good practice, but... +namespace std +{ + template class tuple; +} + +#endif + +namespace boost +{ +namespace mp11 +{ + +// mp_map_find +namespace detail +{ + +#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 ) + +template using mpmf_wrap = mp_identity; +template using mpmf_unwrap = typename T::type; + +#else + +template struct mpmf_tuple {}; + +template struct mpmf_wrap_impl +{ + using type = mp_identity; +}; + +template struct mpmf_wrap_impl< std::tuple > +{ + using type = mp_identity< mpmf_tuple >; +}; + +template using mpmf_wrap = typename mpmf_wrap_impl::type; + +template struct mpmf_unwrap_impl +{ + using type = typename T::type; +}; + +template struct mpmf_unwrap_impl< mp_identity< mpmf_tuple > > +{ + using type = std::tuple; +}; + +template using mpmf_unwrap = typename mpmf_unwrap_impl::type; + +#endif // #if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 ) + +template struct mp_map_find_impl; + +template class M, class... T, class K> struct mp_map_find_impl, K> +{ + using U = mp_inherit...>; + + template class L, class... U> static mp_identity> f( mp_identity>* ); + static mp_identity f( ... ); + + using type = mpmf_unwrap< decltype( f((U*)0) ) >; +}; + +} // namespace detail + +template using mp_map_find = typename detail::mp_map_find_impl::type; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_MAP_FIND_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_min_element.hpp b/3rdparty/boost/boost/mp11/detail/mp_min_element.hpp new file mode 100644 index 0000000000..55c21acd05 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_min_element.hpp @@ -0,0 +1,51 @@ +#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 +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_min_element +namespace detail +{ + +template class P> struct select_min +{ + template using fn = mp_if, T1, T2>; +}; + +} // namespace detail + +template class P> using mp_min_element = mp_fold_q, mp_first, detail::select_min

>; +template using mp_min_element_q = mp_min_element; + +// mp_max_element +namespace detail +{ + +template class P> struct select_max +{ + template using fn = mp_if, T1, T2>; +}; + +} // namespace detail + +template class P> using mp_max_element = mp_fold_q, mp_first, detail::select_max

>; +template using mp_max_element_q = mp_max_element; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_MIN_ELEMENT_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_plus.hpp b/3rdparty/boost/boost/mp11/detail/mp_plus.hpp new file mode 100644 index 0000000000..90ed4c9d11 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_plus.hpp @@ -0,0 +1,81 @@ +#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 +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_plus +namespace detail +{ + +#if defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + +template struct mp_plus_impl +{ + static const auto _v = (T::value + ... + 0); + using type = std::integral_constant::type, _v>; +}; + +#else + +template struct mp_plus_impl; + +template<> struct mp_plus_impl<> +{ + using type = std::integral_constant; +}; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 ) + +template struct mp_plus_impl +{ + static const decltype(T1::value + mp_plus_impl::type::value) _v = T1::value + mp_plus_impl::type::value; + using type = std::integral_constant::type, _v>; +}; + +template struct mp_plus_impl +{ + 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::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::type::value; + using type = std::integral_constant::type, _v>; +}; + +#else + +template struct mp_plus_impl +{ + static const auto _v = T1::value + mp_plus_impl::type::value; + using type = std::integral_constant::type, _v>; +}; + +template struct mp_plus_impl +{ + 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::type::value; + using type = std::integral_constant::type, _v>; +}; + +#endif + +#endif + +} // namespace detail + +template using mp_plus = typename detail::mp_plus_impl::type; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_PLUS_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_remove_if.hpp b/3rdparty/boost/boost/mp11/detail/mp_remove_if.hpp new file mode 100644 index 0000000000..9687b4a16d --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_remove_if.hpp @@ -0,0 +1,48 @@ +#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 +#include +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_remove_if +namespace detail +{ + +template class P> struct mp_remove_if_impl +{ +}; + +template class L, class... T, template class P> struct mp_remove_if_impl, P> +{ +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) + template struct _f { using type = mp_if, mp_list<>, mp_list>; }; + using type = mp_append, typename _f::type...>; +#else + template using _f = mp_if, mp_list<>, mp_list>; + using type = mp_append, _f...>; +#endif +}; + +} // namespace detail + +template class P> using mp_remove_if = typename detail::mp_remove_if_impl::type; +template using mp_remove_if_q = mp_remove_if; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_REMOVE_IF_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_rename.hpp b/3rdparty/boost/boost/mp11/detail/mp_rename.hpp new file mode 100644 index 0000000000..8368ac68ad --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_rename.hpp @@ -0,0 +1,41 @@ +#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 +namespace detail +{ + +template 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 class A, class... T, template class B> struct mp_rename_impl, B> +{ + using type = B; +}; + +} // namespace detail + +template class B> using mp_rename = typename detail::mp_rename_impl::type; + +template class F, class L> using mp_apply = typename detail::mp_rename_impl::type; + +template using mp_apply_q = typename detail::mp_rename_impl::type; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_void.hpp b/3rdparty/boost/boost/mp11/detail/mp_void.hpp new file mode 100644 index 0000000000..a7ac7b7162 --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_void.hpp @@ -0,0 +1,32 @@ +#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 +namespace detail +{ + +template struct mp_void_impl +{ + using type = void; +}; + +} // namespace detail + +template using mp_void = typename detail::mp_void_impl::type; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_VOID_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/detail/mp_with_index.hpp b/3rdparty/boost/boost/mp11/detail/mp_with_index.hpp new file mode 100644 index 0000000000..b6932f2d4f --- /dev/null +++ b/3rdparty/boost/boost/mp11/detail/mp_with_index.hpp @@ -0,0 +1,385 @@ +#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 +#include +#include +#include +#include + +#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 struct mp_with_index_impl_ +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + if( i < N / 2 ) + { + return mp_with_index_impl_::template call( i, std::forward(f) ); + } + else + { + return mp_with_index_impl_::template call( i - N/2, std::forward(f) ); + } + } +}; + +template<> struct mp_with_index_impl_<0> +{ +}; + +template<> struct mp_with_index_impl_<1> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t /*i*/, F && f ) + { + return std::forward(f)( mp_size_t() ); + } +}; + +template<> struct mp_with_index_impl_<2> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<3> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<4> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<5> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<6> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<7> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<8> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<9> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + case 8: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<10> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + case 8: return std::forward(f)( mp_size_t() ); + case 9: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<11> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + case 8: return std::forward(f)( mp_size_t() ); + case 9: return std::forward(f)( mp_size_t() ); + case 10: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<12> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + case 8: return std::forward(f)( mp_size_t() ); + case 9: return std::forward(f)( mp_size_t() ); + case 10: return std::forward(f)( mp_size_t() ); + case 11: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<13> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + case 8: return std::forward(f)( mp_size_t() ); + case 9: return std::forward(f)( mp_size_t() ); + case 10: return std::forward(f)( mp_size_t() ); + case 11: return std::forward(f)( mp_size_t() ); + case 12: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<14> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + case 8: return std::forward(f)( mp_size_t() ); + case 9: return std::forward(f)( mp_size_t() ); + case 10: return std::forward(f)( mp_size_t() ); + case 11: return std::forward(f)( mp_size_t() ); + case 12: return std::forward(f)( mp_size_t() ); + case 13: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<15> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + case 8: return std::forward(f)( mp_size_t() ); + case 9: return std::forward(f)( mp_size_t() ); + case 10: return std::forward(f)( mp_size_t() ); + case 11: return std::forward(f)( mp_size_t() ); + case 12: return std::forward(f)( mp_size_t() ); + case 13: return std::forward(f)( mp_size_t() ); + case 14: return std::forward(f)( mp_size_t() ); + } + } +}; + +template<> struct mp_with_index_impl_<16> +{ + template static BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) call( std::size_t i, F && f ) + { + switch( i ) + { + BOOST_MP11_UNREACHABLE_DEFAULT + case 0: return std::forward(f)( mp_size_t() ); + case 1: return std::forward(f)( mp_size_t() ); + case 2: return std::forward(f)( mp_size_t() ); + case 3: return std::forward(f)( mp_size_t() ); + case 4: return std::forward(f)( mp_size_t() ); + case 5: return std::forward(f)( mp_size_t() ); + case 6: return std::forward(f)( mp_size_t() ); + case 7: return std::forward(f)( mp_size_t() ); + case 8: return std::forward(f)( mp_size_t() ); + case 9: return std::forward(f)( mp_size_t() ); + case 10: return std::forward(f)( mp_size_t() ); + case 11: return std::forward(f)( mp_size_t() ); + case 12: return std::forward(f)( mp_size_t() ); + case 13: return std::forward(f)( mp_size_t() ); + case 14: return std::forward(f)( mp_size_t() ); + case 15: return std::forward(f)( mp_size_t() ); + } + } +}; + +} // namespace detail + +template inline BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) mp_with_index( std::size_t i, F && f ) +{ + assert( i < N ); + return detail::mp_with_index_impl_::template call<0>( i, std::forward(f) ); +} + +template inline BOOST_MP11_CONSTEXPR14 decltype(std::declval()(std::declval>())) mp_with_index( std::size_t i, F && f ) +{ + return mp_with_index( i, std::forward(f) ); +} + +#undef BOOST_MP11_CONSTEXPR14 +#undef BOOST_MP11_UNREACHABLE_DEFAULT + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/function.hpp b/3rdparty/boost/boost/mp11/function.hpp new file mode 100644 index 0000000000..e20b45200a --- /dev/null +++ b/3rdparty/boost/boost/mp11/function.hpp @@ -0,0 +1,222 @@ +#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 +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_void +// in detail/mp_void.hpp + +// mp_and +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1910 ) + +namespace detail +{ + +template struct mp_and_impl; + +} // namespace detail + +template using mp_and = mp_to_bool< typename detail::mp_and_impl::type >; + +namespace detail +{ + +template<> struct mp_and_impl<> +{ + using type = mp_true; +}; + +template struct mp_and_impl +{ + using type = T; +}; + +template struct mp_and_impl +{ + using type = mp_eval_if< mp_not, T1, mp_and, T... >; +}; + +} // namespace detail + +#else + +namespace detail +{ + +template struct mp_and_impl +{ + using type = mp_false; +}; + +template struct mp_and_impl< mp_list, mp_void...> > +{ + using type = mp_true; +}; + +} // namespace detail + +template using mp_and = typename detail::mp_and_impl>::type; + +#endif + +// mp_all +// 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 using mp_all = mp_bool< mp_count_if< mp_list, mp_not >::value == 0 >; + +#else + +template using mp_all = mp_bool< mp_count< mp_list...>, mp_false >::value == 0 >; + +#endif + +// mp_or +namespace detail +{ + +template struct mp_or_impl; + +} // namespace detail + +template using mp_or = mp_to_bool< typename detail::mp_or_impl::type >; + +namespace detail +{ + +template<> struct mp_or_impl<> +{ + using type = mp_false; +}; + +template struct mp_or_impl +{ + using type = T; +}; + +template struct mp_or_impl +{ + using type = mp_eval_if< T1, T1, mp_or, T... >; +}; + +} // namespace detail + +// mp_any +// 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 using mp_any = mp_bool< mp_count_if< mp_list, mp_to_bool >::value != 0 >; + +#else + +template using mp_any = mp_bool< mp_count< mp_list...>, mp_true >::value != 0 >; + +#endif + +// mp_same +namespace detail +{ + +template struct mp_same_impl; + +template<> struct mp_same_impl<> +{ + using type = mp_true; +}; + +template struct mp_same_impl +{ + using type = mp_bool< mp_count, T1>::value == sizeof...(T) >; +}; + +} // namespace detail + +template using mp_same = typename detail::mp_same_impl::type; + +// mp_similar +namespace detail +{ + +template struct mp_similar_impl; + +template<> struct mp_similar_impl<> +{ + using type = mp_true; +}; + +template struct mp_similar_impl +{ + using type = mp_true; +}; + +template struct mp_similar_impl +{ + using type = mp_true; +}; + +template struct mp_similar_impl +{ + using type = mp_false; +}; + +template class L, class... T1, class... T2> struct mp_similar_impl, L> +{ + using type = mp_true; +}; + +template class L, class... T> struct mp_similar_impl, L> +{ + using type = mp_true; +}; + +template struct mp_similar_impl +{ + using type = mp_all< typename mp_similar_impl::type, typename mp_similar_impl::type, typename mp_similar_impl::type... >; +}; + +} // namespace detail + +template using mp_similar = typename detail::mp_similar_impl::type; + +#if BOOST_MP11_GCC +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wsign-compare" +#endif + +// mp_less +template 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 +template using mp_min = mp_min_element, mp_less>; + +// mp_max +template using mp_max = mp_max_element, mp_less>; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_FUNCTION_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/integer_sequence.hpp b/3rdparty/boost/boost/mp11/integer_sequence.hpp new file mode 100644 index 0000000000..83e24501ba --- /dev/null +++ b/3rdparty/boost/boost/mp11/integer_sequence.hpp @@ -0,0 +1,112 @@ +#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 +#include + +#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 struct integer_sequence +{ +}; + +#if defined(BOOST_MP11_HAS_MAKE_INTEGER_SEQ) + +template using make_integer_sequence = __make_integer_seq; + +#else + +// detail::make_integer_sequence_impl +namespace detail +{ + +// iseq_if_c +template struct iseq_if_c_impl; + +template struct iseq_if_c_impl +{ + using type = T; +}; + +template struct iseq_if_c_impl +{ + using type = E; +}; + +template using iseq_if_c = typename iseq_if_c_impl::type; + +// iseq_identity +template struct iseq_identity +{ + using type = T; +}; + +template struct append_integer_sequence; + +template struct append_integer_sequence, integer_sequence> +{ + using type = integer_sequence< T, I..., ( J + sizeof...(I) )... >; +}; + +template struct make_integer_sequence_impl; + +template struct make_integer_sequence_impl_ +{ +private: + + static_assert( N >= 0, "make_integer_sequence: N must not be negative" ); + + static T const M = N / 2; + static T const R = N % 2; + + using S1 = typename make_integer_sequence_impl::type; + using S2 = typename append_integer_sequence::type; + using S3 = typename make_integer_sequence_impl::type; + using S4 = typename append_integer_sequence::type; + +public: + + using type = S4; +}; + +template struct make_integer_sequence_impl: iseq_if_c>, iseq_if_c>, make_integer_sequence_impl_ > > +{ +}; + +} // namespace detail + +// make_integer_sequence +template using make_integer_sequence = typename detail::make_integer_sequence_impl::type; + +#endif // defined(BOOST_MP11_HAS_MAKE_INTEGER_SEQ) + +// index_sequence +template using index_sequence = integer_sequence; + +// make_index_sequence +template using make_index_sequence = make_integer_sequence; + +// index_sequence_for +template using index_sequence_for = make_integer_sequence; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/integral.hpp b/3rdparty/boost/boost/mp11/integral.hpp new file mode 100644 index 0000000000..067167343c --- /dev/null +++ b/3rdparty/boost/boost/mp11/integral.hpp @@ -0,0 +1,41 @@ +#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 +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_bool +template using mp_bool = std::integral_constant; + +using mp_true = mp_bool; +using mp_false = mp_bool; + +// mp_to_bool +template using mp_to_bool = mp_bool( T::value )>; + +// mp_not +template using mp_not = mp_bool< !T::value >; + +// mp_int +template using mp_int = std::integral_constant; + +// mp_size_t +template using mp_size_t = std::integral_constant; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_INTEGRAL_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/list.hpp b/3rdparty/boost/boost/mp11/list.hpp new file mode 100644 index 0000000000..6572a62697 --- /dev/null +++ b/3rdparty/boost/boost/mp11/list.hpp @@ -0,0 +1,304 @@ +#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 +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_list_c +template using mp_list_c = mp_list...>; + +// mp_is_list +// in detail/mp_is_list.hpp + +// mp_size +namespace detail +{ + +template struct mp_size_impl +{ +// An error "no type named 'type'" here means that the argument to mp_size is not a list +}; + +template class L, class... T> struct mp_size_impl> +{ + using type = mp_size_t; +}; + +} // namespace detail + +template using mp_size = typename detail::mp_size_impl::type; + +// mp_empty +template using mp_empty = mp_bool< mp_size::value == 0 >; + +// mp_assign +namespace detail +{ + +template struct mp_assign_impl; + +template class L1, class... T, template class L2, class... U> struct mp_assign_impl, L2> +{ + using type = L1; +}; + +} // namespace detail + +template using mp_assign = typename detail::mp_assign_impl::type; + +// mp_clear +template using mp_clear = mp_assign>; + +// mp_front +// in detail/mp_front.hpp + +// mp_pop_front +namespace detail +{ + +template 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 class L, class T1, class... T> struct mp_pop_front_impl> +{ + using type = L; +}; + +} // namespace detail + +template using mp_pop_front = typename detail::mp_pop_front_impl::type; + +// mp_first +template using mp_first = mp_front; + +// mp_rest +template using mp_rest = mp_pop_front; + +// mp_second +namespace detail +{ + +template 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 class L, class T1, class T2, class... T> struct mp_second_impl> +{ + using type = T2; +}; + +} // namespace detail + +template using mp_second = typename detail::mp_second_impl::type; + +// mp_third +namespace detail +{ + +template 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 class L, class T1, class T2, class T3, class... T> struct mp_third_impl> +{ + using type = T3; +}; + +} // namespace detail + +template using mp_third = typename detail::mp_third_impl::type; + +// mp_push_front +namespace detail +{ + +template 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 class L, class... U, class... T> struct mp_push_front_impl, T...> +{ + using type = L; +}; + +} // namespace detail + +template using mp_push_front = typename detail::mp_push_front_impl::type; + +// mp_push_back +namespace detail +{ + +template 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 class L, class... U, class... T> struct mp_push_back_impl, T...> +{ + using type = L; +}; + +} // namespace detail + +template using mp_push_back = typename detail::mp_push_back_impl::type; + +// mp_rename +// mp_apply +// mp_apply_q +// in detail/mp_rename.hpp + +// mp_replace_front +namespace detail +{ + +template 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 class L, class U1, class... U, class T> struct mp_replace_front_impl, T> +{ + using type = L; +}; + +} // namespace detail + +template using mp_replace_front = typename detail::mp_replace_front_impl::type; + +// mp_replace_first +template using mp_replace_first = typename detail::mp_replace_front_impl::type; + +// mp_replace_second +namespace detail +{ + +template 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 class L, class U1, class U2, class... U, class T> struct mp_replace_second_impl, T> +{ + using type = L; +}; + +} // namespace detail + +template using mp_replace_second = typename detail::mp_replace_second_impl::type; + +// mp_replace_third +namespace detail +{ + +template 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 class L, class U1, class U2, class U3, class... U, class T> struct mp_replace_third_impl, T> +{ + using type = L; +}; + +} // namespace detail + +template using mp_replace_third = typename detail::mp_replace_third_impl::type; + +// mp_transform_front +namespace detail +{ + +template 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 class L, class U1, class... U, template class F> struct mp_transform_front_impl, F> +{ + using type = L, U...>; +}; + +} // namespace detail + +template class F> using mp_transform_front = typename detail::mp_transform_front_impl::type; +template using mp_transform_front_q = mp_transform_front; + +// mp_transform_first +template class F> using mp_transform_first = typename detail::mp_transform_front_impl::type; +template using mp_transform_first_q = mp_transform_first; + +// mp_transform_second +namespace detail +{ + +template 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 class L, class U1, class U2, class... U, template class F> struct mp_transform_second_impl, F> +{ + using type = L, U...>; +}; + +} // namespace detail + +template class F> using mp_transform_second = typename detail::mp_transform_second_impl::type; +template using mp_transform_second_q = mp_transform_second; + +// mp_transform_third +namespace detail +{ + +template 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 class L, class U1, class U2, class U3, class... U, template class F> struct mp_transform_third_impl, F> +{ + using type = L, U...>; +}; + +} // namespace detail + +template class F> using mp_transform_third = typename detail::mp_transform_third_impl::type; +template using mp_transform_third_q = mp_transform_third; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_LIST_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/set.hpp b/3rdparty/boost/boost/mp11/set.hpp new file mode 100644 index 0000000000..808636b72b --- /dev/null +++ b/3rdparty/boost/boost/mp11/set.hpp @@ -0,0 +1,188 @@ +#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 +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_set_contains +namespace detail +{ + +template struct mp_set_contains_impl +{ +}; + +template class L, class... T, class V> struct mp_set_contains_impl, V> +{ + using type = mp_to_bool, mp_inherit...> > >; +}; + +} // namespace detail + +template using mp_set_contains = typename detail::mp_set_contains_impl::type; + +// mp_set_push_back +namespace detail +{ + +template struct mp_set_push_back_impl +{ +}; + +template class L, class... U> struct mp_set_push_back_impl> +{ + using type = L; +}; + +template class L, class... U, class T1, class... T> struct mp_set_push_back_impl, T1, T...> +{ + using S = mp_if, T1>, L, L>; + using type = typename mp_set_push_back_impl::type; +}; + +} // namespace detail + +template using mp_set_push_back = typename detail::mp_set_push_back_impl::type; + +// mp_set_push_front +namespace detail +{ + +template struct mp_set_push_front_impl +{ +}; + +template class L, class... U> struct mp_set_push_front_impl> +{ + using type = L; +}; + +template class L, class... U, class T1> struct mp_set_push_front_impl, T1> +{ + using type = mp_if, T1>, L, L>; +}; + +template class L, class... U, class T1, class... T> struct mp_set_push_front_impl, T1, T...> +{ + using S = typename mp_set_push_front_impl, T...>::type; + using type = typename mp_set_push_front_impl::type; +}; + +} // namespace detail + +template using mp_set_push_front = typename detail::mp_set_push_front_impl::type; + +// mp_is_set +namespace detail +{ + +template struct mp_is_set_impl +{ + using type = mp_false; +}; + +template class L, class... T> struct mp_is_set_impl> +{ + using type = mp_to_bool, mp_set_push_back, T...> > >; +}; + +} // namespace detail + +template using mp_is_set = typename detail::mp_is_set_impl::type; + +// mp_set_union +namespace detail +{ + +template struct mp_set_union_impl +{ +}; + +template<> struct mp_set_union_impl<> +{ + using type = mp_list<>; +}; + +template class L, class... T> struct mp_set_union_impl> +{ + using type = L; +}; + +template class L1, class... T1, template class L2, class... T2> struct mp_set_union_impl, L2> +{ + using type = mp_set_push_back, T2...>; +}; + +template using mp_set_union_ = typename mp_set_union_impl, L...>>::type; + +template struct mp_set_union_impl: mp_defer +{ +}; + +} // namespace detail + +template using mp_set_union = typename detail::mp_set_union_impl::type; + +// mp_set_intersection +namespace detail +{ + +template struct in_all_sets +{ + template using fn = mp_all< mp_set_contains... >; +}; + +template using mp_set_intersection_ = mp_if< mp_all...>, mp_copy_if_q> >; + +template struct mp_set_intersection_impl +{ +}; + +template<> struct mp_set_intersection_impl<> +{ + using type = mp_list<>; +}; + +template struct mp_set_intersection_impl: mp_defer +{ +}; + +} // namespace detail + +template using mp_set_intersection = typename detail::mp_set_intersection_impl::type; + +// mp_set_difference +namespace detail +{ + +template struct in_any_set +{ + template using fn = mp_any< mp_set_contains... >; +}; + +} // namespace detail + +template using mp_set_difference = mp_if< mp_all...>, mp_remove_if_q> >; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_SET_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/utility.hpp b/3rdparty/boost/boost/mp11/utility.hpp new file mode 100644 index 0000000000..fbab4a30f9 --- /dev/null +++ b/3rdparty/boost/boost/mp11/utility.hpp @@ -0,0 +1,263 @@ +#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 +#include +#include +#include +#include +#include + +namespace boost +{ +namespace mp11 +{ + +// mp_identity +template struct mp_identity +{ + using type = T; +}; + +// mp_identity_t +template using mp_identity_t = typename mp_identity::type; + +// mp_inherit +template struct mp_inherit: T... {}; + +// mp_if, mp_if_c +namespace detail +{ + +template struct mp_if_c_impl +{ +}; + +template struct mp_if_c_impl +{ + using type = T; +}; + +template struct mp_if_c_impl +{ + using type = E; +}; + +} // namespace detail + +template using mp_if_c = typename detail::mp_if_c_impl::type; +template using mp_if = typename detail::mp_if_c_impl(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 using void_t = void; + +template class F, class... T> +struct mp_valid_impl: mp_false {}; + +template class F, class... T> +struct mp_valid_impl>, F, T...>: mp_true {}; + +} // namespace detail + +template class F, class... T> using mp_valid = typename detail::mp_valid_impl; + +#else + +// implementation by Bruno Dutra (by the name is_evaluable) +namespace detail +{ + +template class F, class... T> struct mp_valid_impl +{ + template class G, class = G> static mp_true check(int); + template class> static mp_false check(...); + + using type = decltype(check(0)); +}; + +} // namespace detail + +template class F, class... T> using mp_valid = typename detail::mp_valid_impl::type; + +#endif + +template using mp_valid_q = mp_valid; + +// mp_defer +namespace detail +{ + +template class F, class... T> struct mp_defer_impl +{ + using type = F; +}; + +struct mp_no_type +{ +}; + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) + +template class F, class... T> struct mp_defer_cuda_workaround +{ + using type = mp_if, detail::mp_defer_impl, detail::mp_no_type>; +}; + +#endif + +} // namespace detail + +#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 ) + +template class F, class... T> using mp_defer = typename detail::mp_defer_cuda_workaround< F, T...>::type; + +#else + +template class F, class... T> using mp_defer = mp_if, detail::mp_defer_impl, detail::mp_no_type>; + +#endif + +// mp_eval_if, mp_eval_if_c +namespace detail +{ + +template class F, class... U> struct mp_eval_if_c_impl; + +template class F, class... U> struct mp_eval_if_c_impl +{ + using type = T; +}; + +template class F, class... U> struct mp_eval_if_c_impl: mp_defer +{ +}; + +} // namespace detail + +template class F, class... U> using mp_eval_if_c = typename detail::mp_eval_if_c_impl::type; +template class F, class... U> using mp_eval_if = typename detail::mp_eval_if_c_impl(C::value), T, F, U...>::type; +template using mp_eval_if_q = typename detail::mp_eval_if_c_impl(C::value), T, Q::template fn, U...>::type; + +// mp_eval_if_not +template class F, class... U> using mp_eval_if_not = mp_eval_if, T, F, U...>; +template using mp_eval_if_not_q = mp_eval_if, T, Q::template fn, U...>; + +// mp_eval_or +template class F, class... U> using mp_eval_or = mp_eval_if_not, T, F, U...>; +template using mp_eval_or_q = mp_eval_or; + +// mp_valid_and_true +template class F, class... T> using mp_valid_and_true = mp_eval_or; +template using mp_valid_and_true_q = mp_valid_and_true; + +// mp_cond + +// so elegant; so doesn't work +// template using mp_cond = mp_eval_if; + +namespace detail +{ + +template struct mp_cond_impl; + +} // namespace detail + +template using mp_cond = typename detail::mp_cond_impl::type; + +namespace detail +{ + +template using mp_cond_ = mp_eval_if; + +template struct mp_cond_impl: mp_defer +{ +}; + +} // namespace detail + +// mp_quote +template 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 using fn = typename mp_defer::type; +}; + +// mp_quote_trait +template class F> struct mp_quote_trait +{ + template using fn = typename F::type; +}; + +// mp_invoke_q +#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 ) + +namespace detail +{ + +template struct mp_invoke_q_impl: mp_defer {}; + +} // namespace detail + +template using mp_invoke_q = typename detail::mp_invoke_q_impl::type; + +#elif BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 50000 ) + +template using mp_invoke_q = typename mp_defer::type; + +#else + +template using mp_invoke_q = typename Q::template fn; + +#endif + +// mp_not_fn

+template class P> struct mp_not_fn +{ + template using fn = mp_not< mp_invoke_q, T...> >; +}; + +template using mp_not_fn_q = mp_not_fn; + +// mp_compose +namespace detail +{ + +template using mp_compose_helper = mp_list< mp_apply_q >; + +} // namespace detail + +#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 ) + +template class... F> struct mp_compose +{ + template using fn = mp_front< mp_fold...>, mp_list, detail::mp_compose_helper> >; +}; + +#endif + +template struct mp_compose_q +{ + template using fn = mp_front< mp_fold, mp_list, detail::mp_compose_helper> >; +}; + +} // namespace mp11 +} // namespace boost + +#endif // #ifndef BOOST_MP11_UTILITY_HPP_INCLUDED diff --git a/3rdparty/boost/boost/mp11/version.hpp b/3rdparty/boost/boost/mp11/version.hpp new file mode 100644 index 0000000000..5d14c420e8 --- /dev/null +++ b/3rdparty/boost/boost/mp11/version.hpp @@ -0,0 +1,16 @@ +#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 diff --git a/3rdparty/boost/boost/preprocessor/config/config.hpp b/3rdparty/boost/boost/preprocessor/config/config.hpp index 7abaaf050e..3c20672216 100644 --- a/3rdparty/boost/boost/preprocessor/config/config.hpp +++ b/3rdparty/boost/boost/preprocessor/config/config.hpp @@ -1,7 +1,7 @@ # /* ************************************************************************** # * * # * (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) * @@ -76,40 +76,23 @@ # # /* 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 diff --git a/3rdparty/boost/boost/static_assert.hpp b/3rdparty/boost/boost/static_assert.hpp index fd7b224554..d94ca8070c 100644 --- a/3rdparty/boost/boost/static_assert.hpp +++ b/3rdparty/boost/boost/static_assert.hpp @@ -16,6 +16,7 @@ #include #include +#include //for std::size_t #if defined(__GNUC__) && !defined(__GXX_EXPERIMENTAL_CXX0X__) // @@ -36,7 +37,7 @@ # 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 @@ -81,7 +82,7 @@ template struct STATIC_ASSERTION_FAILURE; template <> struct STATIC_ASSERTION_FAILURE { enum { value = 1 }; }; // HP aCC cannot deal with missing names for template value parameters -template struct static_assert_test{}; +template struct static_assert_test{}; } diff --git a/3rdparty/boost/boost/swap.hpp b/3rdparty/boost/boost/swap.hpp deleted file mode 100644 index 55cafa4fdd..0000000000 --- a/3rdparty/boost/boost/swap.hpp +++ /dev/null @@ -1,17 +0,0 @@ -/* - * 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 - -#endif diff --git a/3rdparty/boost/boost/throw_exception.hpp b/3rdparty/boost/boost/throw_exception.hpp index cd77eadea1..cdda86b160 100644 --- a/3rdparty/boost/boost/throw_exception.hpp +++ b/3rdparty/boost/boost/throw_exception.hpp @@ -1,5 +1,5 @@ -#ifndef UUID_AA15E74A856F11E08B8D93F24824019B -#define UUID_AA15E74A856F11E08B8D93F24824019B +#ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED +#define BOOST_THROW_EXCEPTION_HPP_INCLUDED // MS compatible compilers support #pragma once @@ -7,97 +7,272 @@ # 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 +#include #include -#include +#include #include +#include +#include +#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) +#include +#endif -#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x593) ) +#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 ) && defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1310 ) -# define BOOST_EXCEPTION_DISABLE -#endif - -#if !defined( BOOST_EXCEPTION_DISABLE ) -# include -#if !defined(BOOST_THROW_EXCEPTION_CURRENT_FUNCTION) -# include -# define BOOST_THROW_EXCEPTION_CURRENT_FUNCTION BOOST_CURRENT_FUNCTION -#endif -# define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_THROW_EXCEPTION_CURRENT_FUNCTION,__FILE__,__LINE__) -#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) -#endif - namespace boost { -#ifdef BOOST_NO_EXCEPTIONS + +#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 -#else - -inline void throw_exception_assert_compatibility( std::exception const & ) { } - -template BOOST_NORETURN inline void throw_exception( E const & e ) -{ - //All boost exceptions are required to derive from std::exception, - //to ensure compatibility with BOOST_NO_EXCEPTIONS. - throw_exception_assert_compatibility(e); - -#ifndef BOOST_EXCEPTION_DISABLE - throw exception_detail::enable_both( e ); -#else - throw e; #endif + +// boost::wrapexcept + +namespace detail +{ + +typedef char (&wrapexcept_s1)[ 1 ]; +typedef char (&wrapexcept_s2)[ 2 ]; + +template wrapexcept_s1 wrapexcept_is_convertible( T* ); +template wrapexcept_s2 wrapexcept_is_convertible( void* ); + +template( static_cast< E* >( BOOST_NULLPTR ) ) ) > struct wrapexcept_add_base; + +template struct wrapexcept_add_base +{ + struct type {}; +}; + +template struct wrapexcept_add_base +{ + typedef B type; +}; + +} // namespace detail + +template struct BOOST_SYMBOL_VISIBLE wrapexcept: + public detail::wrapexcept_add_base::type, + public E, + public detail::wrapexcept_add_base::type +{ +private: + + struct deleter + { + wrapexcept * p_; + ~deleter() { delete p_; } + }; + +private: + + void copy_from( void const* ) + { + } + + void copy_from( boost::exception const* p ) + { + static_cast( *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 + + 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 BOOST_NORETURN void throw_exception( E const & e ) +{ + throw_exception_assert_compatibility( e ); + throw e; +} + +template 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 BOOST_NORETURN void throw_exception( E const & e ) +{ + throw_exception_assert_compatibility( e ); + throw wrapexcept( e ); +} + +template BOOST_NORETURN void throw_exception( E const & e, boost::source_location const & loc ) +{ + throw_exception_assert_compatibility( e ); + throw wrapexcept( 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 +{ + +// throw_with_location + +namespace detail +{ + +struct BOOST_SYMBOL_VISIBLE throw_location +{ + boost::source_location location_; + + explicit throw_location( boost::source_location const & loc ): location_( loc ) + { + } +}; + +template 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 +}; + +} // namespace detail + +#if !defined(BOOST_NO_EXCEPTIONS) + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) + +template BOOST_NORETURN void throw_with_location( E && e, boost::source_location const & loc = BOOST_CURRENT_LOCATION ) +{ + throw_exception_assert_compatibility( e ); + throw detail::with_throw_location::type>( std::forward( e ), loc ); +} + +#else + +template 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, loc ); } #endif -#if !defined( BOOST_EXCEPTION_DISABLE ) - namespace - exception_detail - { - template - 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))); - } - } +#else + +template BOOST_NORETURN void throw_with_location( E const & e, boost::source_location const & loc = BOOST_CURRENT_LOCATION ) +{ + boost::throw_exception( e, loc ); +} + #endif + +// get_throw_location + +template 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 ) ) + { + 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 diff --git a/3rdparty/boost/boost/type_index.hpp b/3rdparty/boost/boost/type_index.hpp index 6fccf6ee6f..7f06cef687 100644 --- a/3rdparty/boost/boost/type_index.hpp +++ b/3rdparty/boost/boost/type_index.hpp @@ -1,5 +1,5 @@ // -// 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) diff --git a/3rdparty/boost/boost/type_index/ctti_type_index.hpp b/3rdparty/boost/boost/type_index/ctti_type_index.hpp index 27143c4845..9a47eb346b 100644 --- a/3rdparty/boost/boost/type_index/ctti_type_index.hpp +++ b/3rdparty/boost/boost/type_index/ctti_type_index.hpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2013-2019 Antony Polukhin. +// Copyright 2013-2022 Antony Polukhin. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying diff --git a/3rdparty/boost/boost/type_index/detail/compile_time_type_info.hpp b/3rdparty/boost/boost/type_index/detail/compile_time_type_info.hpp index 0197a0170d..f89765dd7e 100644 --- a/3rdparty/boost/boost/type_index/detail/compile_time_type_info.hpp +++ b/3rdparty/boost/boost/type_index/detail/compile_time_type_info.hpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2012-2019 Antony Polukhin. +// Copyright 2012-2022 Antony Polukhin. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying diff --git a/3rdparty/boost/boost/type_index/detail/ctti_register_class.hpp b/3rdparty/boost/boost/type_index/detail/ctti_register_class.hpp index 4879cea296..f527ec4f1e 100644 --- a/3rdparty/boost/boost/type_index/detail/ctti_register_class.hpp +++ b/3rdparty/boost/boost/type_index/detail/ctti_register_class.hpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2013-2019 Antony Polukhin. +// Copyright 2013-2022 Antony Polukhin. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying diff --git a/3rdparty/boost/boost/type_index/detail/stl_register_class.hpp b/3rdparty/boost/boost/type_index/detail/stl_register_class.hpp index ab6c7cfb60..96d83e890a 100644 --- a/3rdparty/boost/boost/type_index/detail/stl_register_class.hpp +++ b/3rdparty/boost/boost/type_index/detail/stl_register_class.hpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2013-2019 Antony Polukhin. +// Copyright 2013-2022 Antony Polukhin. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying diff --git a/3rdparty/boost/boost/type_index/stl_type_index.hpp b/3rdparty/boost/boost/type_index/stl_type_index.hpp index 7d39cd0935..2cbb598d7d 100644 --- a/3rdparty/boost/boost/type_index/stl_type_index.hpp +++ b/3rdparty/boost/boost/type_index/stl_type_index.hpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2013-2019 Antony Polukhin. +// Copyright 2013-2022 Antony Polukhin. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying diff --git a/3rdparty/boost/boost/type_index/type_index_facade.hpp b/3rdparty/boost/boost/type_index/type_index_facade.hpp index 1cb929f620..9c5e5b4566 100644 --- a/3rdparty/boost/boost/type_index/type_index_facade.hpp +++ b/3rdparty/boost/boost/type_index/type_index_facade.hpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2013-2019 Antony Polukhin. +// Copyright 2013-2022 Antony Polukhin. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying diff --git a/3rdparty/boost/boost/type_traits/add_pointer.hpp b/3rdparty/boost/boost/type_traits/add_pointer.hpp index 85ad33a8d9..80b0703707 100644 --- a/3rdparty/boost/boost/type_traits/add_pointer.hpp +++ b/3rdparty/boost/boost/type_traits/add_pointer.hpp @@ -13,7 +13,7 @@ namespace boost { -#if defined(__BORLANDC__) && (__BORLANDC__ < 0x5A0) +#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x5A0) // // For some reason this implementation stops Borlands compiler // from dropping cv-qualifiers, it still fails with references diff --git a/3rdparty/boost/boost/type_traits/alignment_of.hpp b/3rdparty/boost/boost/type_traits/alignment_of.hpp new file mode 100644 index 0000000000..baa3f4d95b --- /dev/null +++ b/3rdparty/boost/boost/type_traits/alignment_of.hpp @@ -0,0 +1,119 @@ + +// (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 +#include + +#include +#include + +#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 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 +struct alignment_of_hack +{ + char c; + T t; + alignment_of_hack(); +}; +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +template +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) - 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) - 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 struct alignment_of : public integral_constant::value>{}; + +// references have to be treated specially, assume +// that a reference is just a special pointer: +template struct alignment_of : public alignment_of{}; + +#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 : public alignment_of{}; +#endif + +// void has to be treated specially: +template<> struct alignment_of : integral_constant{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template<> struct alignment_of : integral_constant{}; +template<> struct alignment_of : integral_constant{}; +template<> struct alignment_of : integral_constant{}; +#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 + diff --git a/3rdparty/boost/boost/type_traits/conjunction.hpp b/3rdparty/boost/boost/type_traits/conjunction.hpp new file mode 100644 index 0000000000..aa5440b60e --- /dev/null +++ b/3rdparty/boost/boost/type_traits/conjunction.hpp @@ -0,0 +1,40 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under the Boost Software License, +Version 1.0. (See accompanying file LICENSE_1_0.txt +or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_TT_CONJUNCTION_HPP_INCLUDED +#define BOOST_TT_CONJUNCTION_HPP_INCLUDED + +#include +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +#include +#endif + +namespace boost { + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +template +struct conjunction + : true_type { }; + +template +struct conjunction + : T { }; + +template +struct conjunction + : conditional, T>::type { }; +#else +template +struct conjunction + : conditional::type { }; +#endif + +} /* boost */ + +#endif diff --git a/3rdparty/boost/boost/type_traits/detail/config.hpp b/3rdparty/boost/boost/type_traits/detail/config.hpp index 7c4b4f2162..679ad08bdf 100644 --- a/3rdparty/boost/boost/type_traits/detail/config.hpp +++ b/3rdparty/boost/boost/type_traits/detail/config.hpp @@ -20,7 +20,7 @@ // it needs to be declared __cdecl to suppress compiler // warnings from MS and Borland compilers (this *must* // appear before we include is_same.hpp below): -#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32)) +#if defined(BOOST_MSVC) || (defined(BOOST_BORLANDC) && !defined(BOOST_DISABLE_WIN32)) # define BOOST_TT_DECL __cdecl #else # define BOOST_TT_DECL /**/ @@ -28,7 +28,7 @@ # if (BOOST_WORKAROUND(__MWERKS__, < 0x3000) \ || BOOST_WORKAROUND(__IBMCPP__, < 600 ) \ - || BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \ + || BOOST_WORKAROUND(BOOST_BORLANDC, < 0x5A0) \ || defined(__ghs) \ || BOOST_WORKAROUND(__HP_aCC, < 60700) \ || BOOST_WORKAROUND(MPW_CPLUS, BOOST_TESTED_AT(0x890)) \ @@ -48,7 +48,7 @@ // when we want to test __stdcall etc function types with is_function etc // (Note, does not work with Borland, even though it does support __stdcall etc): // -#if defined(_MSC_EXTENSIONS) && !defined(__BORLANDC__) +#if defined(_MSC_EXTENSIONS) && !defined(BOOST_BORLANDC) # define BOOST_TT_TEST_MS_FUNC_SIGS #endif @@ -83,7 +83,7 @@ // #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) @@ -107,6 +107,9 @@ #if defined(BOOST_MSVC) && !defined(__cpp_rvalue_references) && !defined(BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE) && !defined(_NOEXCEPT_TYPES_SUPPORTED) # define BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE #endif +#if defined(__cpp_rvalue_references) && defined(__NVCC__) && defined(__CUDACC__) && !defined(BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE) +# define BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE +#endif #endif // BOOST_TT_CONFIG_HPP_INCLUDED diff --git a/3rdparty/boost/boost/type_traits/detail/is_function_cxx_03.hpp b/3rdparty/boost/boost/type_traits/detail/is_function_cxx_03.hpp index d3e4f93659..1b6169ab6d 100644 --- a/3rdparty/boost/boost/type_traits/detail/is_function_cxx_03.hpp +++ b/3rdparty/boost/boost/type_traits/detail/is_function_cxx_03.hpp @@ -28,7 +28,7 @@ namespace boost { -#if !defined( __CODEGEARC__ ) +#if !defined( BOOST_CODEGEARC ) namespace detail { @@ -86,9 +86,9 @@ struct is_function_impl : public false_type } // namespace detail -#endif // !defined( __CODEGEARC__ ) +#endif // !defined( BOOST_CODEGEARC ) -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_function : integral_constant {}; #else template struct is_function : integral_constant::value> {}; diff --git a/3rdparty/boost/boost/type_traits/detail/is_function_cxx_11.hpp b/3rdparty/boost/boost/type_traits/detail/is_function_cxx_11.hpp index 4de74a7373..2dbe1de0ee 100644 --- a/3rdparty/boost/boost/type_traits/detail/is_function_cxx_11.hpp +++ b/3rdparty/boost/boost/type_traits/detail/is_function_cxx_11.hpp @@ -32,276 +32,317 @@ namespace boost { #define BOOST_TT_DEF_CALL #endif +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const qualified: + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // volatile: + +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // Reference qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // rvalue reference qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; + #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) -#ifdef __CLR_VER - template - struct is_function : public true_type {}; -#endif -#ifndef _M_AMD64 + +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_X64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const: + +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; +#endif #endif // reference qualified: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; +#endif #endif // rvalue reference qualified: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif +#endif #endif // _MSC_VER @@ -312,276 +353,314 @@ namespace boost { #undef BOOST_TT_NOEXCEPT_DECL #define BOOST_TT_NOEXCEPT_DECL noexcept +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // Reference qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // rvalue reference qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const qualified: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // volatile: +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; // const volatile +#if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; +#endif template struct is_function : public true_type {}; + #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) -#ifdef __CLR_VER - template - struct is_function : public true_type {}; -#endif -#ifndef _M_AMD64 + +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; +#endif #endif // reference qualified: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; +#endif #endif // rvalue reference qualified: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif - // const volatile: -#ifdef __CLR_VER - template - struct is_function : public true_type {}; #endif -#ifndef _M_AMD64 + // const volatile: +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_function : public true_type {}; -#ifndef __CLR_VER +#endif +#ifdef _MANAGED + template + struct is_function : public true_type {}; +#else +#ifndef _M_AMD64 template struct is_function : 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 struct is_function : public true_type {}; #endif +#endif #endif // defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) diff --git a/3rdparty/boost/boost/type_traits/detail/is_function_ptr_helper.hpp b/3rdparty/boost/boost/type_traits/detail/is_function_ptr_helper.hpp index 73a705cc33..688c5dad91 100644 --- a/3rdparty/boost/boost/type_traits/detail/is_function_ptr_helper.hpp +++ b/3rdparty/boost/boost/type_traits/detail/is_function_ptr_helper.hpp @@ -49,7 +49,7 @@ struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -63,7 +63,7 @@ struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = tr template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -77,7 +77,7 @@ struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -91,7 +91,7 @@ struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, va template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -105,7 +105,7 @@ struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -119,7 +119,7 @@ struct is_function_ptr_helper { BOOST_STATIC_CONSTANT( template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -133,7 +133,7 @@ struct is_function_ptr_helper { BOOST_STATIC_CONST template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -147,7 +147,7 @@ struct is_function_ptr_helper { BOOST_STATIC_C template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -161,7 +161,7 @@ struct is_function_ptr_helper { BOOST_STAT template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -175,7 +175,7 @@ struct is_function_ptr_helper { BOOST_ template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -189,7 +189,7 @@ struct is_function_ptr_helper { BO template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -203,7 +203,7 @@ struct is_function_ptr_helper template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -217,7 +217,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -231,7 +231,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -245,7 +245,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -259,7 +259,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -273,7 +273,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -287,7 +287,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -301,7 +301,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -315,7 +315,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -329,7 +329,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -343,7 +343,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -357,7 +357,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -371,7 +371,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -385,7 +385,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -399,7 +399,7 @@ struct is_function_ptr_helper struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -432,7 +432,7 @@ struct is_function_ptr_helper { template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; @#endif -@#if __cpp_noexcept_function_type +@#ifdef __cpp_noexcept_function_type template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; @#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING diff --git a/3rdparty/boost/boost/type_traits/detail/is_function_ptr_tester.hpp b/3rdparty/boost/boost/type_traits/detail/is_function_ptr_tester.hpp index 41ddd2260f..1c8683c04d 100644 --- a/3rdparty/boost/boost/type_traits/detail/is_function_ptr_tester.hpp +++ b/3rdparty/boost/boost/type_traits/detail/is_function_ptr_tester.hpp @@ -52,7 +52,7 @@ yes_type is_function_ptr_tester(R(*)(...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)()); #endif @@ -72,7 +72,7 @@ yes_type is_function_ptr_tester(R(*)(T0 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0)); #endif @@ -92,7 +92,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1)); #endif @@ -112,7 +112,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2)); #endif @@ -132,7 +132,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3)); #endif @@ -152,7 +152,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4)); #endif @@ -172,7 +172,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5)); #endif @@ -192,7 +192,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6)); #endif @@ -212,7 +212,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7)); #endif @@ -232,7 +232,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)); #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); #endif @@ -252,7 +252,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); #endif @@ -272,7 +272,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); #endif @@ -292,7 +292,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)); #endif @@ -312,7 +312,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)); #endif @@ -332,7 +332,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)); #endif @@ -352,7 +352,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)); #endif @@ -372,7 +372,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -392,7 +392,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -412,7 +412,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -432,7 +432,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -452,7 +452,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -472,7 +472,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -492,7 +492,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -512,7 +512,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -532,7 +532,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -552,7 +552,7 @@ yes_type is_function_ptr_tester(R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 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 @@ -593,7 +593,7 @@ yes_type is_function_ptr_tester(R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) . @#ifdef BOOST_TT_TEST_MS_FUNC_SIGS template 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 yes_type is_function_ptr_tester(R(__vectorcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, T))); @#endif diff --git a/3rdparty/boost/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp b/3rdparty/boost/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp index dcc6e2a0a1..90b825dd07 100644 --- a/3rdparty/boost/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp +++ b/3rdparty/boost/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp @@ -67,7 +67,7 @@ template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -113,7 +113,7 @@ template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -159,7 +159,7 @@ template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -205,7 +205,7 @@ template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -251,7 +251,7 @@ template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -297,7 +297,7 @@ template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -343,7 +343,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -389,7 +389,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -435,7 +435,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -481,7 +481,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -527,7 +527,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -573,7 +573,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -619,7 +619,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -665,7 +665,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -711,7 +711,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -757,7 +757,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -803,7 +803,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -849,7 +849,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -895,7 +895,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -941,7 +941,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -987,7 +987,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -1033,7 +1033,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -1079,7 +1079,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -1125,7 +1125,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -1171,7 +1171,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -1217,7 +1217,7 @@ template { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #endif -#if __cpp_noexcept_function_type +#ifdef __cpp_noexcept_function_type template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING @@ -1290,7 +1290,7 @@ struct is_mem_fun_pointer_impl struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; diff --git a/3rdparty/boost/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp b/3rdparty/boost/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp index 2de883ffb1..083a10fd25 100644 --- a/3rdparty/boost/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp +++ b/3rdparty/boost/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp @@ -69,7 +69,7 @@ template yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)() volatile); template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)()); template @@ -125,7 +125,7 @@ template yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0) volatile); template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0)); template @@ -181,7 +181,7 @@ template yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1) volatile); template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1)); template @@ -237,7 +237,7 @@ template yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2) volatile); template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2)); template @@ -293,7 +293,7 @@ template yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3) volatile); template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3)); template @@ -349,7 +349,7 @@ template yes_type is_mem_fun_pointer_tester(R(__stdcall T::*const volatile*)(T0, T1, T2, T3, T4) volatile); template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4)); template @@ -405,7 +405,7 @@ template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5)); template @@ -461,7 +461,7 @@ template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6)); template @@ -517,7 +517,7 @@ template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7)); template @@ -573,7 +573,7 @@ template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)); template @@ -629,7 +629,7 @@ template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)); template @@ -685,7 +685,7 @@ template 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 yes_type is_mem_fun_pointer_tester(R(__vectorcall T::*const volatile*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); template @@ -741,7 +741,7 @@ template 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 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 @@ -797,7 +797,7 @@ template 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 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 @@ -853,7 +853,7 @@ template 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 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 @@ -909,7 +909,7 @@ template 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 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 @@ -965,7 +965,7 @@ template 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 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 @@ -1021,7 +1021,7 @@ template 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 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 @@ -1077,7 +1077,7 @@ template 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 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 @@ -1133,7 +1133,7 @@ template 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 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 @@ -1189,7 +1189,7 @@ template 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 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 @@ -1245,7 +1245,7 @@ template 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 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 @@ -1301,7 +1301,7 @@ template 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 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 @@ -1357,7 +1357,7 @@ template 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 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 @@ -1413,7 +1413,7 @@ template 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 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 @@ -1469,7 +1469,7 @@ template 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 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 @@ -1557,7 +1557,7 @@ yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_EN template 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 yes_type is_mem_fun_pointer_tester(R (__vectorcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); diff --git a/3rdparty/boost/boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp b/3rdparty/boost/boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp index 3df5b4e7f0..7dbee1d1b8 100644 --- a/3rdparty/boost/boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp +++ b/3rdparty/boost/boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp @@ -11,7 +11,7 @@ #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 @@ -29,9 +29,9 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_member_function_pointer : public integral_constant {}; -#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 struct is_member_function_pointer : public ::boost::integral_constant::type>::value>{}; @@ -40,7 +40,7 @@ template struct is_member_function_pointer namespace detail { -#ifndef __BORLANDC__ +#ifndef BOOST_BORLANDC template struct is_mem_fun_pointer_select diff --git a/3rdparty/boost/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp b/3rdparty/boost/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp index b0502cbe8b..ac3477b38c 100644 --- a/3rdparty/boost/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp +++ b/3rdparty/boost/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp @@ -109,246 +109,259 @@ namespace boost { struct is_member_function_pointer : public true_type {}; #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // reference qualified: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // rvalue reference qualified: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; #endif #endif +#endif + #if defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM) && !defined(BOOST_TT_NO_NOEXCEPT_SEPARATE_TYPE) @@ -420,247 +433,259 @@ namespace boost { struct is_member_function_pointer : public true_type {}; #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // reference qualified: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // rvalue reference qualified: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; +#endif #endif // const volatile: -#ifdef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; - -#endif -#ifndef _M_AMD64 +#if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE) template struct is_member_function_pointer : public true_type {}; -#ifndef __CLR_VER - template - struct is_member_function_pointer : public true_type {}; -#endif template struct is_member_function_pointer : public true_type {}; #endif -#if !defined(__CLR_VER) && (defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)) +#ifdef _MANAGED + template + struct is_member_function_pointer : public true_type {}; +#else +#ifndef _M_AMD64 + template + struct is_member_function_pointer : public true_type {}; +#endif +#if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64) template struct is_member_function_pointer : public true_type {}; #endif #endif +#endif // defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) + #endif diff --git a/3rdparty/boost/boost/type_traits/enable_if.hpp b/3rdparty/boost/boost/type_traits/enable_if.hpp new file mode 100644 index 0000000000..3cdc2816f8 --- /dev/null +++ b/3rdparty/boost/boost/type_traits/enable_if.hpp @@ -0,0 +1,37 @@ +/* +Copyright 2003 The Trustees of Indiana University + +Authors: Jaakko Jarvi (jajarvi at osl.iu.edu) + Jeremiah Willcock (jewillco at osl.iu.edu) + Andrew Lumsdaine (lums at osl.iu.edu) + +Copyright 2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under the Boost Software License, +Version 1.0. (See accompanying file LICENSE_1_0.txt +or copy at http://www.boost.org/LICENSE_1_0.txt) +*/ +#ifndef BOOST_TT_ENABLE_IF_HPP_INCLUDED +#define BOOST_TT_ENABLE_IF_HPP_INCLUDED + +#include + +namespace boost { + +template +struct enable_if_ { + typedef T type; +}; + +template +struct enable_if_ { }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template +using enable_if_t = typename enable_if_::type; +#endif + +} /* boost */ + +#endif diff --git a/3rdparty/boost/boost/type_traits/integral_constant.hpp b/3rdparty/boost/boost/type_traits/integral_constant.hpp index 1b36dbd2c3..2592bcb95d 100644 --- a/3rdparty/boost/boost/type_traits/integral_constant.hpp +++ b/3rdparty/boost/boost/type_traits/integral_constant.hpp @@ -10,7 +10,7 @@ #include #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)) )\ diff --git a/3rdparty/boost/boost/type_traits/intrinsics.hpp b/3rdparty/boost/boost/type_traits/intrinsics.hpp index d41a61ec9a..3ab12d6e06 100644 --- a/3rdparty/boost/boost/type_traits/intrinsics.hpp +++ b/3rdparty/boost/boost/type_traits/intrinsics.hpp @@ -160,7 +160,7 @@ # define BOOST_HAS_TYPE_TRAITS_INTRINSICS #endif -#if defined(BOOST_CLANG) && defined(__has_feature) && !defined(__CUDACC__) +#if defined(BOOST_CLANG) && defined(__has_feature) && defined(__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. @@ -183,25 +183,39 @@ # 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::value) +# elif __has_feature(has_trivial_copy) # define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference::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::value && is_assignable::value) +# elif __has_feature(has_trivial_assign) # define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile::value && is_assignable::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::value) +# elif __has_feature(has_trivial_destructor) # define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) && is_destructible::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::value) +# elif __has_feature(has_nothrow_constructor) # define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) && is_default_constructible::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::value && !is_reference::value && is_copy_constructible::value) +# elif __has_feature(has_nothrow_copy) # define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile::value && !is_reference::value && is_copy_constructible::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::value && is_assignable::value) +# elif __has_feature(has_nothrow_assign) # define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile::value && is_assignable::value) # endif # if __has_feature(has_virtual_destructor) @@ -356,7 +370,7 @@ # define BOOST_HAS_TYPE_TRAITS_INTRINSICS #endif -# if defined(__CODEGEARC__) +# if defined(BOOST_CODEGEARC) # include # include # include diff --git a/3rdparty/boost/boost/type_traits/is_array.hpp b/3rdparty/boost/boost/type_traits/is_array.hpp index 53e1613ab6..16f6a1b227 100644 --- a/3rdparty/boost/boost/type_traits/is_array.hpp +++ b/3rdparty/boost/boost/type_traits/is_array.hpp @@ -19,7 +19,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_array : public integral_constant {}; #else template struct is_array : public false_type {}; @@ -28,7 +28,7 @@ namespace boost { template struct is_array : public true_type{}; template struct is_array : public true_type{}; template struct is_array : 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 struct is_array : public true_type{}; template struct is_array : public true_type{}; template struct is_array : public true_type{}; diff --git a/3rdparty/boost/boost/type_traits/is_complete.hpp b/3rdparty/boost/boost/type_traits/is_complete.hpp index 07cb89749d..08f0e6277a 100644 --- a/3rdparty/boost/boost/type_traits/is_complete.hpp +++ b/3rdparty/boost/boost/type_traits/is_complete.hpp @@ -15,6 +15,7 @@ #include #include #include +#include /* * CAUTION: @@ -40,7 +41,7 @@ namespace boost { namespace detail{ - template + template struct ok_tag { double d; char c[N]; }; template diff --git a/3rdparty/boost/boost/type_traits/is_const.hpp b/3rdparty/boost/boost/type_traits/is_const.hpp index e0ed88a34b..256326f803 100644 --- a/3rdparty/boost/boost/type_traits/is_const.hpp +++ b/3rdparty/boost/boost/type_traits/is_const.hpp @@ -26,7 +26,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_const : public integral_constant {}; diff --git a/3rdparty/boost/boost/type_traits/is_convertible.hpp b/3rdparty/boost/boost/type_traits/is_convertible.hpp index bf648fc46e..f873ef6bfd 100644 --- a/3rdparty/boost/boost/type_traits/is_convertible.hpp +++ b/3rdparty/boost/boost/type_traits/is_convertible.hpp @@ -96,7 +96,7 @@ namespace detail { static const bool value = sizeof(test(0)) == 1; }; -#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560) +#elif defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x560) // // special version for Borland compilers // this version breaks when used for some @@ -120,7 +120,7 @@ struct is_convertible_impl #pragma option pop }; -#elif defined(__GNUC__) || defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +#elif defined(__GNUC__) || defined(BOOST_BORLANDC) && (BOOST_BORLANDC < 0x600) // special version for gcc compiler + recent Borland versions // note that this does not pass UDT's through (...) @@ -358,7 +358,7 @@ struct is_convertible_impl value = ( ::boost::detail::is_convertible_basic_impl::value && ! ::boost::is_array::value && ! ::boost::is_function::value) }; }; -#elif !defined(__BORLANDC__) || __BORLANDC__ > 0x551 +#elif !defined(BOOST_BORLANDC) || BOOST_BORLANDC > 0x551 template struct is_convertible_impl { @@ -489,7 +489,7 @@ struct is_convertible : public integral_constant struct is_convertible : public integral_constant { -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1900) +#if defined(BOOST_MSVC) BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value || boost::is_reference::value, "From argument type to is_convertible must be a complete type"); #endif #if defined(__clang__) diff --git a/3rdparty/boost/boost/type_traits/is_enum.hpp b/3rdparty/boost/boost/type_traits/is_enum.hpp index eada480a65..d23baa1145 100644 --- a/3rdparty/boost/boost/type_traits/is_enum.hpp +++ b/3rdparty/boost/boost/type_traits/is_enum.hpp @@ -32,7 +32,7 @@ namespace boost { #ifndef BOOST_IS_ENUM -#if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)) +#if !(defined(BOOST_BORLANDC) && (BOOST_BORLANDC <= 0x551)) namespace detail { @@ -49,7 +49,7 @@ struct is_class_or_union template 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 static ::boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void)); @@ -131,7 +131,7 @@ template struct is_enum_impl #endif -#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) +#if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) typedef ::boost::detail::is_enum_helper< ::boost::detail::is_enum_impl::selector > se_t; @@ -147,7 +147,7 @@ template struct is_enum_impl template struct is_enum : public integral_constant::value> {}; -#else // __BORLANDC__ +#else // BOOST_BORLANDC // // buggy is_convertible prevents working // implementation of is_enum: diff --git a/3rdparty/boost/boost/type_traits/is_function.hpp b/3rdparty/boost/boost/type_traits/is_function.hpp index 8556235a43..1518f7b8e1 100644 --- a/3rdparty/boost/boost/type_traits/is_function.hpp +++ b/3rdparty/boost/boost/type_traits/is_function.hpp @@ -14,7 +14,7 @@ #include #include -#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION +#ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION #include diff --git a/3rdparty/boost/boost/type_traits/is_integral.hpp b/3rdparty/boost/boost/type_traits/is_integral.hpp index 7a7e54bb70..6c6e239c31 100644 --- a/3rdparty/boost/boost/type_traits/is_integral.hpp +++ b/3rdparty/boost/boost/type_traits/is_integral.hpp @@ -14,7 +14,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_integral : public integral_constant {}; #else @@ -50,14 +50,14 @@ template<> struct is_integral : public true_type{}; // Same set of integral types as in boost/type_traits/integral_promotion.hpp. // Please, keep in sync. -- Alexander Nasonov #if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ - || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) + || (defined(BOOST_BORLANDC) && (BOOST_BORLANDC == 0x600) && (_MSC_VER < 1300)) template<> struct is_integral : public true_type{}; template<> struct is_integral : public true_type{}; template<> struct is_integral : 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 : public true_type{}; template<> struct is_integral<__int64> : public true_type{}; #endif diff --git a/3rdparty/boost/boost/type_traits/is_lvalue_reference.hpp b/3rdparty/boost/boost/type_traits/is_lvalue_reference.hpp index e94d787481..553cb9f4e7 100644 --- a/3rdparty/boost/boost/type_traits/is_lvalue_reference.hpp +++ b/3rdparty/boost/boost/type_traits/is_lvalue_reference.hpp @@ -25,7 +25,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_lvalue_reference : public integral_constant{}; #else diff --git a/3rdparty/boost/boost/type_traits/is_member_function_pointer.hpp b/3rdparty/boost/boost/type_traits/is_member_function_pointer.hpp index 9b5dbbf228..dccd440a5f 100644 --- a/3rdparty/boost/boost/type_traits/is_member_function_pointer.hpp +++ b/3rdparty/boost/boost/type_traits/is_member_function_pointer.hpp @@ -13,7 +13,7 @@ #include -#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION +#ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION #include diff --git a/3rdparty/boost/boost/type_traits/is_member_pointer.hpp b/3rdparty/boost/boost/type_traits/is_member_pointer.hpp index 9757afc950..2078f15b86 100644 --- a/3rdparty/boost/boost/type_traits/is_member_pointer.hpp +++ b/3rdparty/boost/boost/type_traits/is_member_pointer.hpp @@ -26,7 +26,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_member_pointer : public integral_constant{}; #else template struct is_member_pointer : public integral_constant::value>{}; diff --git a/3rdparty/boost/boost/type_traits/is_pointer.hpp b/3rdparty/boost/boost/type_traits/is_pointer.hpp index 44b06c227e..632c3c8883 100644 --- a/3rdparty/boost/boost/type_traits/is_pointer.hpp +++ b/3rdparty/boost/boost/type_traits/is_pointer.hpp @@ -25,7 +25,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_pointer : public integral_constant{}; #else template struct is_pointer : public false_type{}; diff --git a/3rdparty/boost/boost/type_traits/is_same.hpp b/3rdparty/boost/boost/type_traits/is_same.hpp index d16f4b2b1a..9a9ec7e632 100644 --- a/3rdparty/boost/boost/type_traits/is_same.hpp +++ b/3rdparty/boost/boost/type_traits/is_same.hpp @@ -28,7 +28,7 @@ namespace boost { template struct is_same : public false_type {}; template struct is_same : 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 struct is_same : public true_type{}; diff --git a/3rdparty/boost/boost/type_traits/is_signed.hpp b/3rdparty/boost/boost/type_traits/is_signed.hpp index 70ca2e4796..4d50bf8c6f 100644 --- a/3rdparty/boost/boost/type_traits/is_signed.hpp +++ b/3rdparty/boost/boost/type_traits/is_signed.hpp @@ -17,7 +17,7 @@ namespace boost { -#if !defined( __CODEGEARC__ ) +#if !defined( BOOST_CODEGEARC ) #if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1310) && \ !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) &&\ @@ -84,7 +84,7 @@ template struct is_signed : public false_type{}; #endif -#else //defined( __CODEGEARC__ ) +#else //defined( BOOST_CODEGEARC ) template struct is_signed : public integral_constant{}; #endif diff --git a/3rdparty/boost/boost/type_traits/is_unsigned.hpp b/3rdparty/boost/boost/type_traits/is_unsigned.hpp index c4c54af7b3..38b916296d 100644 --- a/3rdparty/boost/boost/type_traits/is_unsigned.hpp +++ b/3rdparty/boost/boost/type_traits/is_unsigned.hpp @@ -18,7 +18,7 @@ namespace boost { -#if !defined( __CODEGEARC__ ) +#if !defined( BOOST_CODEGEARC ) #if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1310) &&\ !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) &&\ @@ -84,7 +84,7 @@ template struct is_unsigned : public false_type{}; #endif -#else // defined( __CODEGEARC__ ) +#else // defined( BOOST_CODEGEARC ) template struct is_unsigned : public integral_constant {}; #endif diff --git a/3rdparty/boost/boost/type_traits/is_volatile.hpp b/3rdparty/boost/boost/type_traits/is_volatile.hpp index 5b8e716b47..3f9b0630a7 100644 --- a/3rdparty/boost/boost/type_traits/is_volatile.hpp +++ b/3rdparty/boost/boost/type_traits/is_volatile.hpp @@ -26,7 +26,7 @@ namespace boost { -#if defined( __CODEGEARC__ ) +#if defined( BOOST_CODEGEARC ) template struct is_volatile : public integral_constant {}; diff --git a/3rdparty/boost/boost/type_traits/make_unsigned.hpp b/3rdparty/boost/boost/type_traits/make_unsigned.hpp new file mode 100644 index 0000000000..17a8a5b929 --- /dev/null +++ b/3rdparty/boost/boost/type_traits/make_unsigned.hpp @@ -0,0 +1,136 @@ + +// (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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + +template +struct make_unsigned +{ +private: + BOOST_STATIC_ASSERT_MSG((::boost::is_integral::value || ::boost::is_enum::value), "The template argument to make_unsigned must be an integer or enum type."); + BOOST_STATIC_ASSERT_MSG((! ::boost::is_same::type, bool>::value), "The template argument to make_unsigned must not be the type bool"); + + typedef typename remove_cv::type t_no_cv; + typedef typename conditional< + (::boost::is_unsigned::value && ::boost::is_integral::value + && ! ::boost::is_same::value + && ! ::boost::is_same::value + && ! ::boost::is_same::value), + T, + typename conditional< + (::boost::is_integral::value + && ! ::boost::is_same::value + && ! ::boost::is_same::value + && ! ::boost::is_same::value), + typename conditional< + is_same::value, + unsigned char, + typename conditional< + is_same::value, + unsigned short, + typename conditional< + is_same::value, + unsigned int, + typename conditional< + is_same::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::value, + typename add_const::type, + base_integer_type + >::type const_base_integer_type; +public: + // Add back any volatile qualifier: + typedef typename conditional< + is_volatile::value, + typename add_volatile::type, + const_base_integer_type + >::type type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using make_unsigned_t = typename make_unsigned::type; + +#endif + +} // namespace boost + +#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED + diff --git a/3rdparty/boost/boost/type_traits/remove_cv.hpp b/3rdparty/boost/boost/type_traits/remove_cv.hpp index 57a96f29d6..2a68af533e 100644 --- a/3rdparty/boost/boost/type_traits/remove_cv.hpp +++ b/3rdparty/boost/boost/type_traits/remove_cv.hpp @@ -27,7 +27,7 @@ template struct remove_cv{ typedef T type; }; template struct remove_cv{ typedef T type[N]; }; template struct remove_cv{ typedef T type[N]; }; template struct remove_cv{ 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 struct remove_cv{ typedef T type[]; }; template struct remove_cv{ typedef T type[]; }; template struct remove_cv{ typedef T type[]; }; diff --git a/3rdparty/boost/boost/type_traits/remove_extent.hpp b/3rdparty/boost/boost/type_traits/remove_extent.hpp index 55d57301b7..866f4bce07 100644 --- a/3rdparty/boost/boost/type_traits/remove_extent.hpp +++ b/3rdparty/boost/boost/type_traits/remove_extent.hpp @@ -22,7 +22,7 @@ template struct remove_extent { typedef T type template struct remove_extent { typedef T const type; }; template struct remove_extent { typedef T volatile type; }; template struct remove_extent { 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 struct remove_extent { typedef T type; }; template struct remove_extent { typedef T const type; }; template struct remove_extent { typedef T volatile type; }; diff --git a/3rdparty/boost/boost/version.hpp b/3rdparty/boost/boost/version.hpp index 2adc0dfc77..63ed52e5ab 100644 --- a/3rdparty/boost/boost/version.hpp +++ b/3rdparty/boost/boost/version.hpp @@ -19,7 +19,7 @@ // 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 @@ -27,6 +27,6 @@ // number, y is the minor version number, and z is the patch level if not 0. // This is used by to select which library version to link to. -#define BOOST_LIB_VERSION "1_72" +#define BOOST_LIB_VERSION "1_81" #endif