From c98c8dab5c5296f612ad2cc8e887926daa81d0d2 Mon Sep 17 00:00:00 2001 From: Jean-Marc Lasgouttes Date: Fri, 23 Nov 2018 16:14:23 +0100 Subject: [PATCH] Update to boost 1.68 This avoids warnings from gcc 8 --- 3rdparty/boost/boost/bind/bind.hpp | 37 + 3rdparty/boost/boost/bind/bind_cc.hpp | 60 +- 3rdparty/boost/boost/bind/bind_mf_cc.hpp | 72 +- 3rdparty/boost/boost/config/auto_link.hpp | 30 +- .../boost/boost/config/compiler/borland.hpp | 4 + .../boost/boost/config/compiler/clang.hpp | 17 +- .../boost/boost/config/compiler/codegear.hpp | 4 + .../boost/config/compiler/common_edg.hpp | 4 + 3rdparty/boost/boost/config/compiler/cray.hpp | 442 ++++- 3rdparty/boost/boost/config/compiler/diab.hpp | 9 +- .../boost/config/compiler/digitalmars.hpp | 3 + 3rdparty/boost/boost/config/compiler/gcc.hpp | 20 +- .../boost/boost/config/compiler/gcc_xml.hpp | 3 + .../boost/boost/config/compiler/intel.hpp | 9 +- .../boost/config/compiler/metrowerks.hpp | 3 + 3rdparty/boost/boost/config/compiler/mpw.hpp | 3 + 3rdparty/boost/boost/config/compiler/nvcc.hpp | 6 +- .../boost/boost/config/compiler/pathscale.hpp | 3 + 3rdparty/boost/boost/config/compiler/pgi.hpp | 161 +- .../boost/boost/config/compiler/sunpro_cc.hpp | 9 +- .../boost/boost/config/compiler/vacpp.hpp | 8 + .../boost/boost/config/compiler/visualc.hpp | 33 +- .../boost/boost/config/compiler/xlcpp.hpp | 9 + .../boost/boost/config/compiler/xlcpp_zos.hpp | 2 + .../config/detail/select_compiler_config.hpp | 8 +- 3rdparty/boost/boost/config/detail/suffix.hpp | 32 +- .../boost/boost/config/header_deprecated.hpp | 26 + 3rdparty/boost/boost/config/helper_macros.hpp | 37 + .../boost/boost/config/platform/cygwin.hpp | 11 + .../boost/boost/config/platform/vxworks.hpp | 233 ++- .../boost/boost/config/pragma_message.hpp | 31 + .../boost/boost/config/stdlib/dinkumware.hpp | 11 +- .../boost/boost/config/stdlib/libcomo.hpp | 1 + 3rdparty/boost/boost/config/stdlib/libcpp.hpp | 13 +- .../boost/boost/config/stdlib/libstdcpp3.hpp | 9 +- 3rdparty/boost/boost/config/stdlib/modena.hpp | 1 + 3rdparty/boost/boost/config/stdlib/msl.hpp | 1 + .../boost/boost/config/stdlib/roguewave.hpp | 1 + 3rdparty/boost/boost/config/stdlib/sgi.hpp | 1 + .../boost/boost/config/stdlib/stlport.hpp | 1 + 3rdparty/boost/boost/config/stdlib/vacpp.hpp | 1 + .../boost/boost/config/stdlib/xlcpp_zos.hpp | 1 + 3rdparty/boost/boost/config/workaround.hpp | 2 + .../boost/boost/container/container_fwd.hpp | 35 +- .../detail/float_functions.hpp | 0 .../detail/hash_float.hpp | 8 +- .../hash => container_hash}/detail/limits.hpp | 0 .../hash => container_hash}/extensions.hpp | 128 +- .../hash => container_hash}/hash.hpp | 180 +- .../hash => container_hash}/hash_fwd.hpp | 6 +- 3rdparty/boost/boost/core/addressof.hpp | 84 +- 3rdparty/boost/boost/cstdint.hpp | 30 +- .../boost/boost/detail/basic_pointerbuf.hpp | 2 +- 3rdparty/boost/boost/function.hpp | 16 +- .../function/detail/gen_maybe_include.pl | 2 + .../boost/function/detail/maybe_include.hpp | 102 + .../boost/boost/function/function_base.hpp | 20 + .../boost/function/function_template.hpp | 17 +- .../boost/boost/function_output_iterator.hpp | 56 +- 3rdparty/boost/boost/functional/hash.hpp | 3 +- 3rdparty/boost/boost/functional/hash_fwd.hpp | 7 +- 3rdparty/boost/boost/iterator.hpp | 20 - 3rdparty/boost/boost/iterator/distance.hpp | 65 + .../iterator/function_output_iterator.hpp | 62 + .../boost/boost/iterator/iterator_adaptor.hpp | 2 - .../boost/iterator/iterator_categories.hpp | 5 +- .../boost/iterator/iterator_concepts.hpp | 18 +- .../boost/boost/iterator/iterator_facade.hpp | 3 +- .../boost/boost/iterator/iterator_traits.hpp | 13 +- .../boost/boost/iterator/reverse_iterator.hpp | 1 - .../detail/converter_lexical_streams.hpp | 14 +- .../boost/boost/math/common_factor_ct.hpp | 28 - .../special_functions/detail/fp_traits.hpp | 3 +- .../boost/math/special_functions/math_fwd.hpp | 39 +- 3rdparty/boost/boost/math/tools/config.hpp | 15 +- 3rdparty/boost/boost/move/adl_move_swap.hpp | 6 + 3rdparty/boost/boost/move/core.hpp | 16 +- .../boost/boost/move/detail/type_traits.hpp | 24 +- 3rdparty/boost/boost/mpl/assert.hpp | 17 +- 3rdparty/boost/boost/next_prior.hpp | 21 +- .../boost/boost/numeric/conversion/cast.hpp | 2 +- .../numeric/conversion/conversion_traits.hpp | 7 - .../numeric/conversion/detail/converter.hpp | 17 +- .../conversion/detail/old_numeric_cast.hpp | 37 +- .../detail/old_optional_implementation.hpp | 20 +- .../detail/optional_aligned_storage.hpp | 38 +- .../boost/optional/detail/optional_config.hpp | 31 +- .../detail/optional_reference_spec.hpp | 51 +- .../boost/optional/detail/optional_relops.hpp | 2 +- .../optional_trivially_copyable_base.hpp | 499 +++++ 3rdparty/boost/boost/optional/optional.hpp | 427 +++- 3rdparty/boost/boost/parameter.hpp | 0 .../boost/boost/parameter/aux_/overloads.hpp | 0 .../parameter/aux_/parameter_requirements.hpp | 0 .../parameter/aux_/preprocessor/flatten.hpp | 0 .../parameter/aux_/preprocessor/for_each.hpp | 0 .../boost/boost/parameter/aux_/result_of0.hpp | 0 3rdparty/boost/boost/parameter/aux_/tag.hpp | 0 .../boost/parameter/aux_/template_keyword.hpp | 0 3rdparty/boost/boost/parameter/aux_/void.hpp | 0 3rdparty/boost/boost/parameter/aux_/yesno.hpp | 0 3rdparty/boost/boost/parameter/match.hpp | 0 3rdparty/boost/boost/parameter/parameters.hpp | 0 3rdparty/boost/boost/predef/architecture.h | 1 + .../boost/boost/predef/architecture/arm.h | 5 + .../boost/boost/predef/architecture/parisc.h | 2 +- .../boost/boost/predef/architecture/ptx.h | 44 + 3rdparty/boost/boost/predef/compiler.h | 1 + 3rdparty/boost/boost/predef/compiler/nvcc.h | 60 + 3rdparty/boost/boost/predef/language.h | 1 + 3rdparty/boost/boost/predef/language/cuda.h | 52 + 3rdparty/boost/boost/predef/library/c.h | 1 + .../boost/boost/predef/library/c/cloudabi.h | 53 + 3rdparty/boost/boost/predef/make.h | 8 + 3rdparty/boost/boost/predef/os/android.h | 4 +- 3rdparty/boost/boost/predef/os/bsd/free.h | 13 +- 3rdparty/boost/boost/predef/os/bsd/open.h | 80 + 3rdparty/boost/boost/predef/other/endian.h | 3 +- 3rdparty/boost/boost/predef/platform.h | 10 +- .../boost/boost/predef/platform/cloudabi.h | 43 + 3rdparty/boost/boost/predef/platform/mingw.h | 4 +- .../boost/boost/predef/platform/mingw32.h | 63 + .../boost/boost/predef/platform/mingw64.h | 63 + .../boost/predef/platform/windows_desktop.h | 12 +- .../boost/predef/platform/windows_phone.h | 9 +- .../boost/predef/platform/windows_runtime.h | 18 +- .../boost/predef/platform/windows_server.h | 47 + .../boost/predef/platform/windows_store.h | 15 +- .../boost/predef/platform/windows_system.h | 47 + .../boost/boost/predef/platform/windows_uwp.h | 60 + 3rdparty/boost/boost/predef/version.h | 2 +- .../boost/preprocessor/config/config.hpp | 4 +- 3rdparty/boost/boost/range/begin.hpp | 14 +- 3rdparty/boost/boost/range/concepts.hpp | 12 +- 3rdparty/boost/boost/range/detail/begin.hpp | 8 +- 3rdparty/boost/boost/range/detail/common.hpp | 4 +- 3rdparty/boost/boost/range/detail/end.hpp | 8 +- .../range/detail/implementation_help.hpp | 4 +- 3rdparty/boost/boost/range/distance.hpp | 7 +- 3rdparty/boost/boost/range/end.hpp | 16 +- .../boost/boost/range/has_range_iterator.hpp | 6 +- .../boost/boost/range/iterator_range_core.hpp | 1 + 3rdparty/boost/boost/regex/config.hpp | 2 +- .../boost/regex/pending/object_cache.hpp | 4 +- .../boost/regex/v4/basic_regex_creator.hpp | 4 +- .../boost/regex/v4/basic_regex_parser.hpp | 67 +- .../boost/boost/regex/v4/perl_matcher.hpp | 9 +- .../boost/regex/v4/perl_matcher_common.hpp | 7 +- .../regex/v4/perl_matcher_non_recursive.hpp | 50 +- .../boost/regex/v4/perl_matcher_recursive.hpp | 8 +- .../boost/regex/v4/regex_traits_defaults.hpp | 15 +- .../boost/boost/regex/v4/regex_workaround.hpp | 2 +- .../boost/boost/signals2/deconstruct_ptr.hpp | 6 +- .../boost/signals2/detail/lwm_win32_cs.hpp | 60 +- 3rdparty/boost/boost/signals2/last_value.hpp | 2 +- 3rdparty/boost/boost/signals2/slot_base.hpp | 5 +- .../boost/smart_ptr/detail/lwm_win32_cs.hpp | 25 +- .../detail/sp_counted_base_clang.hpp | 4 +- .../detail/sp_counted_base_gcc_mips.hpp | 6 + .../detail/sp_counted_base_std_atomic.hpp | 4 +- .../boost/smart_ptr/detail/sp_interlocked.hpp | 5 + .../boost/boost/smart_ptr/detail/yield_k.hpp | 22 +- 3rdparty/boost/boost/smart_ptr/shared_ptr.hpp | 8 +- .../boost/boost/tuple/detail/tuple_basic.hpp | 16 +- 3rdparty/boost/boost/tuple/tuple.hpp | 16 +- 3rdparty/boost/boost/type_index.hpp | 2 +- .../boost/type_index/ctti_type_index.hpp | 4 +- .../detail/compile_time_type_info.hpp | 18 +- .../boost/boost/type_index/stl_type_index.hpp | 23 +- .../boost/type_index/type_index_facade.hpp | 12 +- .../boost/boost/type_traits/conditional.hpp | 2 + .../boost/boost/type_traits/detail/config.hpp | 13 +- .../detail/has_binary_operator.hpp | 85 +- .../detail/is_function_ptr_helper.hpp | 472 ++++- .../type_traits/detail/is_likely_lambda.hpp | 94 + .../detail/is_mem_fun_pointer_impl.hpp | 1749 +++++++++++------ .../detail/is_mem_fun_pointer_tester.hpp | 4 +- .../boost/boost/type_traits/has_minus.hpp | 98 + .../boost/type_traits/has_minus_assign.hpp | 102 +- .../boost/type_traits/has_plus_assign.hpp | 95 + .../boost/type_traits/integral_constant.hpp | 23 +- .../boost/boost/type_traits/intrinsics.hpp | 25 +- .../boost/boost/type_traits/is_assignable.hpp | 12 +- .../boost/boost/type_traits/is_complete.hpp | 92 + .../boost/type_traits/is_constructible.hpp | 14 +- .../boost/type_traits/is_convertible.hpp | 22 +- .../type_traits/is_default_constructible.hpp | 18 +- .../boost/type_traits/is_destructible.hpp | 12 +- .../is_nothrow_move_assignable.hpp | 17 +- .../is_nothrow_move_constructible.hpp | 18 +- .../boost/boost/type_traits/make_void.hpp | 52 + .../boost/type_traits/remove_pointer.hpp | 1 + .../boost/boost/type_traits/type_identity.hpp | 31 + .../boost/type_traits/type_with_alignment.hpp | 5 +- 3rdparty/boost/boost/utility.hpp | 9 +- .../utility/detail/result_of_iterate.hpp | 31 +- 3rdparty/boost/boost/utility/result_of.hpp | 59 +- .../variant/detail/apply_visitor_binary.hpp | 164 +- .../variant/detail/apply_visitor_unary.hpp | 48 +- 3rdparty/boost/boost/variant/variant.hpp | 102 +- 3rdparty/boost/boost/version.hpp | 4 +- 201 files changed, 6298 insertions(+), 1957 deletions(-) create mode 100644 3rdparty/boost/boost/config/header_deprecated.hpp create mode 100644 3rdparty/boost/boost/config/helper_macros.hpp create mode 100644 3rdparty/boost/boost/config/pragma_message.hpp rename 3rdparty/boost/boost/{functional/hash => container_hash}/detail/float_functions.hpp (100%) rename 3rdparty/boost/boost/{functional/hash => container_hash}/detail/hash_float.hpp (97%) rename 3rdparty/boost/boost/{functional/hash => container_hash}/detail/limits.hpp (100%) rename 3rdparty/boost/boost/{functional/hash => container_hash}/extensions.hpp (70%) rename 3rdparty/boost/boost/{functional/hash => container_hash}/hash.hpp (79%) rename 3rdparty/boost/boost/{functional/hash => container_hash}/hash_fwd.hpp (93%) delete mode 100644 3rdparty/boost/boost/iterator.hpp create mode 100644 3rdparty/boost/boost/iterator/distance.hpp create mode 100644 3rdparty/boost/boost/iterator/function_output_iterator.hpp delete mode 100644 3rdparty/boost/boost/math/common_factor_ct.hpp mode change 100755 => 100644 3rdparty/boost/boost/numeric/conversion/detail/old_numeric_cast.hpp create mode 100644 3rdparty/boost/boost/optional/detail/optional_trivially_copyable_base.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/overloads.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/parameter_requirements.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/preprocessor/flatten.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/preprocessor/for_each.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/result_of0.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/tag.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/template_keyword.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/void.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/aux_/yesno.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/match.hpp mode change 100755 => 100644 3rdparty/boost/boost/parameter/parameters.hpp create mode 100644 3rdparty/boost/boost/predef/architecture/ptx.h create mode 100644 3rdparty/boost/boost/predef/compiler/nvcc.h create mode 100644 3rdparty/boost/boost/predef/language/cuda.h create mode 100644 3rdparty/boost/boost/predef/library/c/cloudabi.h create mode 100644 3rdparty/boost/boost/predef/platform/cloudabi.h create mode 100644 3rdparty/boost/boost/predef/platform/mingw32.h create mode 100644 3rdparty/boost/boost/predef/platform/mingw64.h create mode 100644 3rdparty/boost/boost/predef/platform/windows_server.h create mode 100644 3rdparty/boost/boost/predef/platform/windows_system.h create mode 100644 3rdparty/boost/boost/predef/platform/windows_uwp.h create mode 100644 3rdparty/boost/boost/type_traits/detail/is_likely_lambda.hpp create mode 100644 3rdparty/boost/boost/type_traits/is_complete.hpp create mode 100644 3rdparty/boost/boost/type_traits/make_void.hpp create mode 100644 3rdparty/boost/boost/type_traits/type_identity.hpp diff --git a/3rdparty/boost/boost/bind/bind.hpp b/3rdparty/boost/boost/bind/bind.hpp index 85d675a0e3..4cedc5e9a4 100644 --- a/3rdparty/boost/boost/bind/bind.hpp +++ b/3rdparty/boost/boost/bind/bind.hpp @@ -2122,21 +2122,31 @@ template +# if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED ) +# undef BOOST_BIND_NOEXCEPT +# define BOOST_BIND_NOEXCEPT noexcept +# include +# endif + #undef BOOST_BIND_CC #undef BOOST_BIND_ST +#undef BOOST_BIND_NOEXCEPT #ifdef BOOST_BIND_ENABLE_STDCALL #define BOOST_BIND_CC __stdcall #define BOOST_BIND_ST +#define BOOST_BIND_NOEXCEPT #include #undef BOOST_BIND_CC #undef BOOST_BIND_ST +#undef BOOST_BIND_NOEXCEPT #endif @@ -2144,11 +2154,13 @@ template #undef BOOST_BIND_CC #undef BOOST_BIND_ST +#undef BOOST_BIND_NOEXCEPT #endif @@ -2156,11 +2168,13 @@ template #undef BOOST_BIND_ST #undef BOOST_BIND_CC +#undef BOOST_BIND_NOEXCEPT #endif @@ -2168,23 +2182,33 @@ template #include +# if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED ) +# undef BOOST_BIND_MF_NOEXCEPT +# define BOOST_BIND_MF_NOEXCEPT noexcept +# include +# endif + #undef BOOST_BIND_MF_NAME #undef BOOST_BIND_MF_CC +#undef BOOST_BIND_MF_NOEXCEPT #ifdef BOOST_MEM_FN_ENABLE_CDECL #define BOOST_BIND_MF_NAME(X) X##_cdecl #define BOOST_BIND_MF_CC __cdecl +#define BOOST_BIND_MF_NOEXCEPT #include #include #undef BOOST_BIND_MF_NAME #undef BOOST_BIND_MF_CC +#undef BOOST_BIND_MF_NOEXCEPT #endif @@ -2192,12 +2216,14 @@ template #include #undef BOOST_BIND_MF_NAME #undef BOOST_BIND_MF_CC +#undef BOOST_BIND_MF_NOEXCEPT #endif @@ -2205,12 +2231,14 @@ template #include #undef BOOST_BIND_MF_NAME #undef BOOST_BIND_MF_CC +#undef BOOST_BIND_MF_NOEXCEPT #endif @@ -2264,6 +2292,15 @@ template< class R, class T > struct add_cref< R (T::*) () const, 1 > typedef void type; }; +#if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED ) + +template< class R, class T > struct add_cref< R (T::*) () const noexcept, 1 > +{ + typedef void type; +}; + +#endif // __cpp_noexcept_function_type + #endif // __IBMCPP__ template struct isref diff --git a/3rdparty/boost/boost/bind/bind_cc.hpp b/3rdparty/boost/boost/bind/bind_cc.hpp index 35f8eceb9e..278aa9a2a8 100644 --- a/3rdparty/boost/boost/bind/bind_cc.hpp +++ b/3rdparty/boost/boost/bind/bind_cc.hpp @@ -13,28 +13,28 @@ // template - _bi::bind_t - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) ()) + _bi::bind_t + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) () BOOST_BIND_NOEXCEPT) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) () BOOST_BIND_NOEXCEPT; typedef _bi::list0 list_type; return _bi::bind_t (f, list_type()); } template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1), A1 a1) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1) BOOST_BIND_NOEXCEPT, A1 a1) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_1::type list_type; return _bi::bind_t (f, list_type(a1)); } template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2), A1 a1, A2 a2) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_2::type list_type; return _bi::bind_t (f, list_type(a1, a2)); } @@ -42,10 +42,10 @@ template template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_3::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3)); } @@ -53,10 +53,10 @@ template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_4::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4)); } @@ -64,10 +64,10 @@ template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_5::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5)); } @@ -75,10 +75,10 @@ template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_6::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6)); } @@ -86,10 +86,10 @@ template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_7::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7)); } @@ -97,10 +97,10 @@ template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_8::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8)); } @@ -108,10 +108,10 @@ template - _bi::bind_t::type> - BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) + _bi::bind_t::type> + BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { - typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9); + typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9) BOOST_BIND_NOEXCEPT; typedef typename _bi::list_av_9::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); } diff --git a/3rdparty/boost/boost/bind/bind_mf_cc.hpp b/3rdparty/boost/boost/bind/bind_mf_cc.hpp index e149384ff5..bbfd3719b6 100644 --- a/3rdparty/boost/boost/bind/bind_mf_cc.hpp +++ b/3rdparty/boost/boost/bind/bind_mf_cc.hpp @@ -17,7 +17,7 @@ template _bi::bind_t, typename _bi::list_av_1::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1) { typedef _mfi::BOOST_BIND_MF_NAME(mf0) F; typedef typename _bi::list_av_1::type list_type; @@ -27,7 +27,7 @@ template _bi::bind_t, typename _bi::list_av_1::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1) { typedef _mfi::BOOST_BIND_MF_NAME(cmf0) F; typedef typename _bi::list_av_1::type list_type; @@ -38,7 +38,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_1::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1) { typedef _mfi::BOOST_BIND_MF_NAME(mf0) F; typedef typename _bi::list_av_1::type list_type; @@ -49,7 +49,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_1::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1) { typedef _mfi::BOOST_BIND_MF_NAME(cmf0) F; typedef typename _bi::list_av_1::type list_type; @@ -62,7 +62,7 @@ template _bi::bind_t, typename _bi::list_av_2::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2) { typedef _mfi::BOOST_BIND_MF_NAME(mf1) F; typedef typename _bi::list_av_2::type list_type; @@ -73,7 +73,7 @@ template _bi::bind_t, typename _bi::list_av_2::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2) { typedef _mfi::BOOST_BIND_MF_NAME(cmf1) F; typedef typename _bi::list_av_2::type list_type; @@ -85,7 +85,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_2::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2) { typedef _mfi::BOOST_BIND_MF_NAME(mf1) F; typedef typename _bi::list_av_2::type list_type; @@ -97,7 +97,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_2::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2) { typedef _mfi::BOOST_BIND_MF_NAME(cmf1) F; typedef typename _bi::list_av_2::type list_type; @@ -110,7 +110,7 @@ template _bi::bind_t, typename _bi::list_av_3::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3) { typedef _mfi::BOOST_BIND_MF_NAME(mf2) F; typedef typename _bi::list_av_3::type list_type; @@ -121,7 +121,7 @@ template _bi::bind_t, typename _bi::list_av_3::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3) { typedef _mfi::BOOST_BIND_MF_NAME(cmf2) F; typedef typename _bi::list_av_3::type list_type; @@ -133,7 +133,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_3::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3) { typedef _mfi::BOOST_BIND_MF_NAME(mf2) F; typedef typename _bi::list_av_3::type list_type; @@ -145,7 +145,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_3::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3) { typedef _mfi::BOOST_BIND_MF_NAME(cmf2) F; typedef typename _bi::list_av_3::type list_type; @@ -158,7 +158,7 @@ template _bi::bind_t, typename _bi::list_av_4::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4) { typedef _mfi::BOOST_BIND_MF_NAME(mf3) F; typedef typename _bi::list_av_4::type list_type; @@ -169,7 +169,7 @@ template _bi::bind_t, typename _bi::list_av_4::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4) { typedef _mfi::BOOST_BIND_MF_NAME(cmf3) F; typedef typename _bi::list_av_4::type list_type; @@ -181,7 +181,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_4::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4) { typedef _mfi::BOOST_BIND_MF_NAME(mf3) F; typedef typename _bi::list_av_4::type list_type; @@ -193,7 +193,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_4::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4) { typedef _mfi::BOOST_BIND_MF_NAME(cmf3) F; typedef typename _bi::list_av_4::type list_type; @@ -206,7 +206,7 @@ template _bi::bind_t, typename _bi::list_av_5::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef _mfi::BOOST_BIND_MF_NAME(mf4) F; typedef typename _bi::list_av_5::type list_type; @@ -217,7 +217,7 @@ template _bi::bind_t, typename _bi::list_av_5::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef _mfi::BOOST_BIND_MF_NAME(cmf4) F; typedef typename _bi::list_av_5::type list_type; @@ -229,7 +229,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_5::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef _mfi::BOOST_BIND_MF_NAME(mf4) F; typedef typename _bi::list_av_5::type list_type; @@ -241,7 +241,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_5::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef _mfi::BOOST_BIND_MF_NAME(cmf4) F; typedef typename _bi::list_av_5::type list_type; @@ -254,7 +254,7 @@ template _bi::bind_t, typename _bi::list_av_6::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef _mfi::BOOST_BIND_MF_NAME(mf5) F; typedef typename _bi::list_av_6::type list_type; @@ -265,7 +265,7 @@ template _bi::bind_t, typename _bi::list_av_6::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef _mfi::BOOST_BIND_MF_NAME(cmf5) F; typedef typename _bi::list_av_6::type list_type; @@ -277,7 +277,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_6::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef _mfi::BOOST_BIND_MF_NAME(mf5) F; typedef typename _bi::list_av_6::type list_type; @@ -289,7 +289,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_6::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef _mfi::BOOST_BIND_MF_NAME(cmf5) F; typedef typename _bi::list_av_6::type list_type; @@ -302,7 +302,7 @@ template _bi::bind_t, typename _bi::list_av_7::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef _mfi::BOOST_BIND_MF_NAME(mf6) F; typedef typename _bi::list_av_7::type list_type; @@ -313,7 +313,7 @@ template _bi::bind_t, typename _bi::list_av_7::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef _mfi::BOOST_BIND_MF_NAME(cmf6) F; typedef typename _bi::list_av_7::type list_type; @@ -325,7 +325,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_7::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef _mfi::BOOST_BIND_MF_NAME(mf6) F; typedef typename _bi::list_av_7::type list_type; @@ -337,7 +337,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_7::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef _mfi::BOOST_BIND_MF_NAME(cmf6) F; typedef typename _bi::list_av_7::type list_type; @@ -350,7 +350,7 @@ template _bi::bind_t, typename _bi::list_av_8::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef _mfi::BOOST_BIND_MF_NAME(mf7) F; typedef typename _bi::list_av_8::type list_type; @@ -361,7 +361,7 @@ template _bi::bind_t, typename _bi::list_av_8::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef _mfi::BOOST_BIND_MF_NAME(cmf7) F; typedef typename _bi::list_av_8::type list_type; @@ -373,7 +373,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_8::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef _mfi::BOOST_BIND_MF_NAME(mf7) F; typedef typename _bi::list_av_8::type list_type; @@ -385,7 +385,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_8::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef _mfi::BOOST_BIND_MF_NAME(cmf7) F; typedef typename _bi::list_av_8::type list_type; @@ -398,7 +398,7 @@ template _bi::bind_t, typename _bi::list_av_9::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef _mfi::BOOST_BIND_MF_NAME(mf8) F; typedef typename _bi::list_av_9::type list_type; @@ -409,7 +409,7 @@ template _bi::bind_t, typename _bi::list_av_9::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) + BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef _mfi::BOOST_BIND_MF_NAME(cmf8) F; typedef typename _bi::list_av_9::type list_type; @@ -421,7 +421,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_9::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef _mfi::BOOST_BIND_MF_NAME(mf8) F; typedef typename _bi::list_av_9::type list_type; @@ -433,7 +433,7 @@ template typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_9::type> - >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef _mfi::BOOST_BIND_MF_NAME(cmf8) F; typedef typename _bi::list_av_9::type list_type; diff --git a/3rdparty/boost/boost/config/auto_link.hpp b/3rdparty/boost/boost/config/auto_link.hpp index c71e8035dd..271f837911 100644 --- a/3rdparty/boost/boost/config/auto_link.hpp +++ b/3rdparty/boost/boost/config/auto_link.hpp @@ -45,6 +45,7 @@ BOOST_LIB_PREFIX + BOOST_LIB_TOOLSET + BOOST_LIB_THREAD_OPT + BOOST_LIB_RT_OPT + + BOOST_LIB_ARCH_AND_MODEL_OPT "-" + BOOST_LIB_VERSION @@ -69,6 +70,9 @@ BOOST_LIB_RT_OPT: A suffix that indicates the runtime library used, p STLport build. n STLport build without its IOStreams. +BOOST_LIB_ARCH_AND_MODEL_OPT: The architecture and address model + (-x32 or -x64 for x86/32 and x86/64 respectively) + BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. @@ -361,6 +365,20 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. #endif +// +// BOOST_LIB_ARCH_AND_MODEL_OPT +// + +#if defined( _M_IX86 ) +# define BOOST_LIB_ARCH_AND_MODEL_OPT "-x32" +#elif defined( _M_X64 ) +# define BOOST_LIB_ARCH_AND_MODEL_OPT "-x64" +#elif defined( _M_ARM ) +# define BOOST_LIB_ARCH_AND_MODEL_OPT "-a32" +#elif defined( _M_ARM64 ) +# define BOOST_LIB_ARCH_AND_MODEL_OPT "-a64" +#endif + // // select linkage opt: // @@ -380,6 +398,7 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. && defined(BOOST_LIB_TOOLSET) \ && defined(BOOST_LIB_THREAD_OPT) \ && defined(BOOST_LIB_RT_OPT) \ + && defined(BOOST_LIB_ARCH_AND_MODEL_OPT) \ && defined(BOOST_LIB_VERSION) #ifdef BOOST_AUTO_LINK_TAGGED @@ -393,14 +412,14 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. # pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib") # 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_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) ".lib") # 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_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) ".lib") # 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_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 ".lib") # 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_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 ".lib") # endif #endif @@ -431,6 +450,9 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. #if defined(BOOST_LIB_RT_OPT) # undef BOOST_LIB_RT_OPT #endif +#if defined(BOOST_LIB_ARCH_AND_MODEL_OPT) +# undef BOOST_LIB_ARCH_AND_MODEL_OPT +#endif #if defined(BOOST_LIB_LINK_OPT) # undef BOOST_LIB_LINK_OPT #endif diff --git a/3rdparty/boost/boost/config/compiler/borland.hpp b/3rdparty/boost/boost/config/compiler/borland.hpp index fa891def41..cb164f8f2a 100644 --- a/3rdparty/boost/boost/config/compiler/borland.hpp +++ b/3rdparty/boost/boost/config/compiler/borland.hpp @@ -174,6 +174,7 @@ #define BOOST_NO_CXX11_CONSTEXPR #define BOOST_NO_CXX11_DECLTYPE_N3276 #define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS +#define BOOST_NO_CXX11_DEFAULTED_MOVES #define BOOST_NO_CXX11_DELETED_FUNCTIONS #define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS #define BOOST_NO_CXX11_HDR_INITIALIZER_LIST @@ -238,6 +239,9 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif #if __BORLANDC__ >= 0x590 # define BOOST_HAS_TR1_HASH diff --git a/3rdparty/boost/boost/config/compiler/clang.hpp b/3rdparty/boost/boost/config/compiler/clang.hpp index 157a94d267..3d893c689a 100644 --- a/3rdparty/boost/boost/config/compiler/clang.hpp +++ b/3rdparty/boost/boost/config/compiler/clang.hpp @@ -98,11 +98,15 @@ // // Dynamic shared object (DSO) and dynamic-link library (DLL) support // -#if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32) +#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__) +# define BOOST_HAS_DECLSPEC +# define BOOST_SYMBOL_EXPORT __attribute__((__dllexport__)) +# define BOOST_SYMBOL_IMPORT __attribute__((__dllimport__)) +#else # define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default"))) # define BOOST_SYMBOL_IMPORT -# define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default"))) #endif +#define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default"))) // // The BOOST_FALLTHROUGH macro can be used to annotate implicit fall-through @@ -290,6 +294,10 @@ # define BOOST_NO_CXX17_STRUCTURED_BINDINGS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif + // Clang 3.9+ in c++1z #if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L # define BOOST_NO_CXX17_INLINE_VARIABLES @@ -318,6 +326,11 @@ // Clang has supported the 'unused' attribute since the first release. #define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__)) +// Type aliasing hint. +#if __has_attribute(__may_alias__) +# define BOOST_MAY_ALIAS __attribute__((__may_alias__)) +#endif + #ifndef BOOST_COMPILER # define BOOST_COMPILER "Clang version " __clang_version__ #endif diff --git a/3rdparty/boost/boost/config/compiler/codegear.hpp b/3rdparty/boost/boost/config/compiler/codegear.hpp index 44ca8428e4..c2cfe15c64 100644 --- a/3rdparty/boost/boost/config/compiler/codegear.hpp +++ b/3rdparty/boost/boost/config/compiler/codegear.hpp @@ -167,6 +167,10 @@ # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif + // // TR1 macros: // diff --git a/3rdparty/boost/boost/config/compiler/common_edg.hpp b/3rdparty/boost/boost/config/compiler/common_edg.hpp index d49ceb68e2..88aba9ac8f 100644 --- a/3rdparty/boost/boost/config/compiler/common_edg.hpp +++ b/3rdparty/boost/boost/config/compiler/common_edg.hpp @@ -149,6 +149,10 @@ # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif + #ifdef c_plusplus // EDG has "long long" in non-strict mode // However, some libraries have insufficient "long long" support diff --git a/3rdparty/boost/boost/config/compiler/cray.hpp b/3rdparty/boost/boost/config/compiler/cray.hpp index eab5287751..412ef9efa5 100644 --- a/3rdparty/boost/boost/config/compiler/cray.hpp +++ b/3rdparty/boost/boost/config/compiler/cray.hpp @@ -1,68 +1,227 @@ -// (C) Copyright John Maddock 2011. -// (C) Copyright Cray, Inc. 2013 +// Copyright 2011 John Maddock +// Copyright 2013, 2017-2018 Cray, Inc. // 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. -// Greenhills C compiler setup: +// Cray C++ compiler setup. +// +// There are a few parameters that affect the macros defined in this file: +// +// - What version of CCE (Cray Compiling Environment) are we running? This +// comes from the '_RELEASE_MAJOR', '_RELEASE_MINOR', and +// '_RELEASE_PATCHLEVEL' macros. +// - What C++ standards conformance level are we using (e.g. '-h +// std=c++14')? This comes from the '__cplusplus' macro. +// - Are we using GCC extensions ('-h gnu' or '-h nognu')? If we have '-h +// gnu' then CCE emulates GCC, and the macros '__GNUC__', +// '__GNUC_MINOR__', and '__GNUC_PATCHLEVEL__' are defined. +// +// This file is organized as follows: +// +// - Verify that the combination of parameters listed above is supported. +// If we have an unsupported combination, we abort with '#error'. +// - Establish baseline values for all Boost macros. +// - Apply changes to the baseline macros based on compiler version. These +// changes are cummulative so each version section only describes the +// changes since the previous version. +// - Within each version section, we may also apply changes based on +// other parameters (i.e. C++ standards conformance level and GCC +// extensions). +// +// To test changes to this file: +// +// ``` +// module load cce/8.6.5 # Pick the version you want to test. +// cd boost/libs/config/test/all +// b2 -j 8 toolset=cray cxxstd=03 cxxstd=11 cxxstd=14 cxxstd-dialect=gnu linkflags=-lrt +// ``` +// Note: Using 'cxxstd-dialect=iso' is not supported at this time (the +// tests run, but many tests fail). +// +// Note: 'linkflags=-lrt' is needed in Cray Linux Environment. Otherwise +// you get an 'undefined reference to clock_gettime' error. +// +// Note: If a test '*_fail.cpp' file compiles, but fails to run, then it is +// reported as a defect. However, this is not actually a defect. This is an +// area where the test system is somewhat broken. Tests that are failing +// because of this problem are noted in the comments. +// +// Pay attention to the macro definitions for the macros you wish to +// modify. For example, only macros categorized as compiler macros should +// appear in this file; platform macros should not appear in this file. +// Also, some macros have to be defined to specific values; it is not +// always enough to define or undefine a macro. +// +// Macro definitions are available in the source code at: +// +// `boost/libs/config/doc/html/boost_config/boost_macro_reference.html` +// +// Macro definitions are also available online at: +// +// http://www.boost.org/doc/libs/master/libs/config/doc/html/boost_config/boost_macro_reference.html +// +// Typically, if you enable a feature, and the tests pass, then you have +// nothing to worry about. However, it's sometimes hard to figure out if a +// disabled feature needs to stay disabled. To get a list of disabled +// features, run 'b2' in 'boost/libs/config/checks'. These are the macros +// you should pay attention to (in addition to macros that cause test +// failures). -#define BOOST_COMPILER "Cray C version " BOOST_STRINGIZE(_RELEASE) +//// +//// Front matter +//// -#if _RELEASE < 8 -# error "Boost is not configured for Cray compilers prior to version 8, please try the configure script." +// In a developer build of the Cray compiler (i.e. a compiler built by a +// Cray employee), the release patch level is reported as "x". This gives +// versions that look like e.g. "8.6.x". +// +// To accomplish this, the the Cray compiler preprocessor inserts: +// +// #define _RELEASE_PATCHLEVEL x +// +// If we are using a developer build of the compiler, we want to use the +// configuration macros for the most recent patch level of the release. To +// accomplish this, we'll pretend that _RELEASE_PATCHLEVEL is 99. +// +// However, it's difficult to detect if _RELEASE_PATCHLEVEL is x. We must +// consider that the x will be expanded if x is defined as a macro +// elsewhere. For example, imagine if someone put "-D x=3" on the command +// line, and _RELEASE_PATCHLEVEL is x. Then _RELEASE_PATCHLEVEL would +// expand to 3, and we could not distinguish it from an actual +// _RELEASE_PATCHLEVEL of 3. This problem only affects developer builds; in +// production builds, _RELEASE_PATCHLEVEL is always an integer. +// +// IMPORTANT: In developer builds, if x is defined as a macro, you will get +// an incorrect configuration. The behavior in this case is undefined. +// +// Even if x is not defined, we have to use some trickery to detect if +// _RELEASE_PATCHLEVEL is x. First we define BOOST_CRAY_x to some arbitrary +// magic value, 9867657. Then we use BOOST_CRAY_APPEND to append the +// expanded value of _RELEASE_PATCHLEVEL to the string "BOOST_CRAY_". +// +// - If _RELEASE_PATCHLEVEL is undefined, we get "BOOST_CRAY_". +// - If _RELEASE_PATCHLEVEL is 5, we get "BOOST_CRAY_5". +// - If _RELEASE_PATCHLEVEL is x (and x is not defined) we get +// "BOOST_CRAY_x": +// +// Then we check if BOOST_CRAY_x is equal to the output of +// BOOST_CRAY_APPEND. In other words, the output of BOOST_CRAY_APPEND is +// treated as a macro name, and expanded again. If we can safely assume +// that BOOST_CRAY_ is not a macro defined as our magic number, and +// BOOST_CRAY_5 is not a macro defined as our magic number, then the only +// way the equality test can pass is if _RELEASE_PATCHLEVEL expands to x. +// +// So, that is how we detect if we are using a developer build of the Cray +// compiler. + +#define BOOST_CRAY_x 9867657 // Arbitrary number +#define BOOST_CRAY_APPEND(MACRO) BOOST_CRAY_APPEND_INTERNAL(MACRO) +#define BOOST_CRAY_APPEND_INTERNAL(MACRO) BOOST_CRAY_##MACRO + +#if BOOST_CRAY_x == BOOST_CRAY_APPEND(_RELEASE_PATCHLEVEL) + + // This is a developer build. + // + // - _RELEASE_PATCHLEVEL is defined as x, and x is not defined as a macro. + + // Pretend _RELEASE_PATCHLEVEL is 99, so we get the configuration for the + // most recent patch level in this release. + + #define BOOST_CRAY_VERSION (_RELEASE_MAJOR * 10000 + _RELEASE_MINOR * 100 + 99) + +#else + + // This is a production build. + // + // _RELEASE_PATCHLEVEL is not defined as x, or x is defined as a macro. + + #define BOOST_CRAY_VERSION (_RELEASE_MAJOR * 10000 + _RELEASE_MINOR * 100 + _RELEASE_PATCHLEVEL) + +#endif // BOOST_CRAY_x == BOOST_CRAY_APPEND(_RELEASE_PATCHLEVEL) + +#undef BOOST_CRAY_APPEND_INTERNAL +#undef BOOST_CRAY_APPEND +#undef BOOST_CRAY_x + + +#ifdef __GNUC__ +# define BOOST_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) #endif +#ifndef BOOST_COMPILER +# define BOOST_COMPILER "Cray C++ version " BOOST_STRINGIZE(_RELEASE_MAJOR) "." BOOST_STRINGIZE(_RELEASE_MINOR) "." BOOST_STRINGIZE(_RELEASE_PATCHLEVEL) +#endif + +// Since the Cray compiler defines '__GNUC__', we have to emulate some +// additional GCC macros in order to make everything work. // -// Check this is a recent EDG based compiler, otherwise we don't support it here: -// -#ifndef __EDG_VERSION__ +// FIXME: Perhaps Cray should fix the compiler to define these additional +// macros for GCC emulation? + +#if __cplusplus >= 201103L && defined(__GNUC__) && !defined(__GXX_EXPERIMENTAL_CXX0X__) +# define __GXX_EXPERIMENTAL_CXX0X__ 1 +#endif + +//// +//// Parameter validation +//// + +// FIXME: Do we really need to support compilers before 8.5? Do they pass +// the Boost.Config tests? + +#if BOOST_CRAY_VERSION < 80000 +# error "Boost is not configured for Cray compilers prior to version 8, please try the configure script." +#endif + +// We only support recent EDG based compilers. + +#ifndef __EDG__ # error "Unsupported Cray compiler, please try running the configure script." #endif -#include +//// +//// Baseline values +//// +#include -// -// -#define BOOST_NO_CXX11_STATIC_ASSERT +#define BOOST_HAS_NRVO +#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION #define BOOST_NO_CXX11_AUTO_DECLARATIONS #define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS -#define BOOST_HAS_NRVO -#define BOOST_NO_CXX11_VARIADIC_MACROS -#define BOOST_NO_CXX11_VARIADIC_TEMPLATES -#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX -#define BOOST_NO_CXX11_UNICODE_LITERALS -#define BOOST_NO_TWO_PHASE_NAME_LOOKUP -#define BOOST_HAS_NRVO -#define BOOST_NO_CXX11_TEMPLATE_ALIASES -#define BOOST_NO_CXX11_STATIC_ASSERT -#define BOOST_NO_SFINAE_EXPR -#define BOOST_NO_CXX11_SFINAE_EXPR -#define BOOST_NO_CXX11_SCOPED_ENUMS -#define BOOST_NO_CXX11_RVALUE_REFERENCES -#define BOOST_NO_CXX11_RANGE_BASED_FOR -#define BOOST_NO_CXX11_RAW_LITERALS -#define BOOST_NO_CXX11_NULLPTR -#define BOOST_NO_CXX11_NOEXCEPT +#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_FINAL +#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_FUNCTION_TEMPLATE_DEFAULT_ARGS -#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS -#define BOOST_NO_CXX11_DELETED_FUNCTIONS -#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS -#define BOOST_NO_CXX11_DECLTYPE_N3276 -#define BOOST_NO_CXX11_DECLTYPE -#define BOOST_NO_CXX11_CONSTEXPR -#define BOOST_NO_CXX11_USER_DEFINED_LITERALS -#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION -#define BOOST_NO_CXX11_CHAR32_T -#define BOOST_NO_CXX11_CHAR16_T +#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_REF_QUALIFIERS -#define BOOST_NO_CXX11_FINAL +#define BOOST_NO_CXX11_RVALUE_REFERENCES +#define BOOST_NO_CXX11_SCOPED_ENUMS +#define BOOST_NO_CXX11_SFINAE_EXPR +#define BOOST_NO_CXX11_STATIC_ASSERT +#define BOOST_NO_CXX11_TEMPLATE_ALIASES #define BOOST_NO_CXX11_THREAD_LOCAL - +#define BOOST_NO_CXX11_UNICODE_LITERALS +#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX +#define BOOST_NO_CXX11_USER_DEFINED_LITERALS +#define BOOST_NO_CXX11_VARIADIC_MACROS +#define BOOST_NO_CXX11_VARIADIC_TEMPLATES +#define BOOST_NO_SFINAE_EXPR +#define BOOST_NO_TWO_PHASE_NAME_LOOKUP //#define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG #define BOOST_MATH_DISABLE_STD_FPCLASSIFY @@ -71,15 +230,15 @@ #define BOOST_SP_USE_PTHREADS #define BOOST_AC_USE_PTHREADS -/* everything that follows is working around what are thought to be - * compiler shortcomings. Revist all of these regularly. - */ +// +// Everything that follows is working around what are thought to be +// compiler shortcomings. Revist all of these regularly. +// //#define BOOST_USE_ENUM_STATIC_ASSERT //#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS //(this may be implied by the previous #define -// These constants should be provided by the -// compiler, at least when -hgnu is asserted on the command line. +// These constants should be provided by the compiler. #ifndef __ATOMIC_RELAXED #define __ATOMIC_RELAXED 0 @@ -90,5 +249,192 @@ #define __ATOMIC_SEQ_CST 5 #endif +//// +//// Version changes +//// + +// +// 8.5.0 +// + +#if BOOST_CRAY_VERSION >= 80500 + +#if __cplusplus >= 201103L + +#undef BOOST_HAS_NRVO +#undef BOOST_NO_COMPLETE_VALUE_INITIALIZATION +#undef BOOST_NO_CXX11_AUTO_DECLARATIONS +#undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS +#undef BOOST_NO_CXX11_CHAR16_T +#undef BOOST_NO_CXX11_CHAR32_T +#undef BOOST_NO_CXX11_CONSTEXPR +#undef BOOST_NO_CXX11_DECLTYPE +#undef BOOST_NO_CXX11_DECLTYPE_N3276 +#undef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS +#undef BOOST_NO_CXX11_DELETED_FUNCTIONS +#undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS +#undef BOOST_NO_CXX11_FINAL +#undef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS +#undef BOOST_NO_CXX11_LAMBDAS +#undef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS +#undef BOOST_NO_CXX11_NOEXCEPT +#undef BOOST_NO_CXX11_NULLPTR +#undef BOOST_NO_CXX11_RANGE_BASED_FOR +#undef BOOST_NO_CXX11_RAW_LITERALS +#undef BOOST_NO_CXX11_REF_QUALIFIERS +#undef BOOST_NO_CXX11_RVALUE_REFERENCES +#undef BOOST_NO_CXX11_SCOPED_ENUMS +#undef BOOST_NO_CXX11_SFINAE_EXPR +#undef BOOST_NO_CXX11_STATIC_ASSERT +#undef BOOST_NO_CXX11_TEMPLATE_ALIASES +#undef BOOST_NO_CXX11_THREAD_LOCAL +#undef BOOST_NO_CXX11_UNICODE_LITERALS +#undef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX +#undef BOOST_NO_CXX11_USER_DEFINED_LITERALS +#undef BOOST_NO_CXX11_VARIADIC_MACROS +#undef BOOST_NO_CXX11_VARIADIC_TEMPLATES +#undef BOOST_NO_SFINAE_EXPR +#undef BOOST_NO_TWO_PHASE_NAME_LOOKUP +#undef BOOST_MATH_DISABLE_STD_FPCLASSIFY +#undef BOOST_SP_USE_PTHREADS +#undef BOOST_AC_USE_PTHREADS + +#define BOOST_HAS_VARIADIC_TMPL +#define BOOST_HAS_UNISTD_H +#define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG +#define BOOST_HAS_TR1_COMPLEX_OVERLOADS +#define BOOST_HAS_STDINT_H +#define BOOST_HAS_STATIC_ASSERT +#define BOOST_HAS_SIGACTION +#define BOOST_HAS_SCHED_YIELD +#define BOOST_HAS_RVALUE_REFS +#define BOOST_HAS_PTHREADS +#define BOOST_HAS_PTHREAD_YIELD +#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +#define BOOST_HAS_PARTIAL_STD_ALLOCATOR +#define BOOST_HAS_NRVO +#define BOOST_HAS_NL_TYPES_H +#define BOOST_HAS_NANOSLEEP +#define BOOST_NO_CXX11_SMART_PTR +#define BOOST_NO_CXX11_HDR_FUNCTIONAL +#define BOOST_NO_CXX14_CONSTEXPR +#define BOOST_HAS_LONG_LONG +#define BOOST_HAS_FLOAT128 + +#if __cplusplus < 201402L +#define BOOST_NO_CXX11_DECLTYPE_N3276 +#endif // __cplusplus < 201402L + +#endif // __cplusplus >= 201103L + +#endif // BOOST_CRAY_VERSION >= 80500 + +// +// 8.6.4 +// (versions prior to 8.6.5 do not define _RELEASE_PATCHLEVEL) +// + +#if BOOST_CRAY_VERSION >= 80600 + +#if __cplusplus >= 199711L +#define BOOST_HAS_FLOAT128 +#define BOOST_HAS_PTHREAD_YIELD // This is a platform macro, but it improves test results. +#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION // This is correct. Test compiles, but fails to run. +#undef BOOST_NO_CXX11_CHAR16_T +#undef BOOST_NO_CXX11_CHAR32_T +#undef BOOST_NO_CXX11_INLINE_NAMESPACES +#undef BOOST_NO_CXX11_FINAL +#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. +#undef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX +#undef BOOST_NO_CXX11_VARIADIC_MACROS +#undef BOOST_NO_CXX11_VARIADIC_TEMPLATES +// 'BOOST_NO_DEDUCED_TYPENAME' test is broken. The test files are enabled / +// disabled with an '#ifdef BOOST_DEDUCED_TYPENAME'. However, +// 'boost/libs/config/include/boost/config/detail/suffix.hpp' ensures that +// 'BOOST_DEDUCED_TYPENAME' is always defined (the value it is defined as +// depends on 'BOOST_NO_DEDUCED_TYPENAME'). So, modifying +// 'BOOST_NO_DEDUCED_TYPENAME' has no effect on which tests are run. +// +// The 'no_ded_typename_pass.cpp' test should always compile and run +// successfully, because 'BOOST_DEDUCED_TYPENAME' must always have an +// appropriate value (it's not just something that you turn on or off). +// Therefore, if you wish to test changes to 'BOOST_NO_DEDUCED_TYPENAME', +// you have to modify 'no_ded_typename_pass.cpp' to unconditionally include +// 'boost_no_ded_typename.ipp'. +#undef BOOST_NO_DEDUCED_TYPENAME // This is correct. Test is broken. +#undef BOOST_NO_SFINAE_EXPR +#undef BOOST_NO_TWO_PHASE_NAME_LOOKUP +#endif // __cplusplus >= 199711L + +#if __cplusplus >= 201103L +#undef BOOST_NO_CXX11_ALIGNAS +#undef BOOST_NO_CXX11_DECLTYPE_N3276 +#define BOOST_NO_CXX11_HDR_ATOMIC +#undef BOOST_NO_CXX11_HDR_FUNCTIONAL +#define BOOST_NO_CXX11_HDR_REGEX // This is correct. Test compiles, but fails to run. +#undef BOOST_NO_CXX11_SFINAE_EXPR +#undef BOOST_NO_CXX11_SMART_PTR +#undef BOOST_NO_CXX11_TRAILING_RESULT_TYPES +#endif // __cplusplus >= 201103L + +#if __cplusplus >= 201402L +#undef BOOST_NO_CXX14_CONSTEXPR +#define BOOST_NO_CXX14_DIGIT_SEPARATORS +#endif // __cplusplus == 201402L + +#endif // BOOST_CRAY_VERSION >= 80600 + +// +// 8.6.5 +// (no change from 8.6.4) +// + +// +// 8.7.0 +// + +#if BOOST_CRAY_VERSION >= 80700 + +#if __cplusplus >= 199711L +#endif // __cplusplus >= 199711L + +#if __cplusplus >= 201103L +#undef BOOST_NO_CXX11_HDR_ATOMIC +#undef BOOST_NO_CXX11_HDR_REGEX +#endif // __cplusplus >= 201103L + +#if __cplusplus >= 201402L +#endif // __cplusplus == 201402L + +#endif // BOOST_CRAY_VERSION >= 80700 + +// +// Next release +// + +#if BOOST_CRAY_VERSION > 80799 + +#if __cplusplus >= 199711L +#endif // __cplusplus >= 199711L + +#if __cplusplus >= 201103L +#endif // __cplusplus >= 201103L + +#if __cplusplus >= 201402L +#endif // __cplusplus == 201402L + +#endif // BOOST_CRAY_VERSION > 80799 + +//// +//// Remove temporary macros +//// +// I've commented out some '#undef' statements to signify that we purposely +// want to keep certain macros. +//#undef __GXX_EXPERIMENTAL_CXX0X__ +//#undef BOOST_COMPILER +#undef BOOST_GCC_VERSION +#undef BOOST_CRAY_VERSION diff --git a/3rdparty/boost/boost/config/compiler/diab.hpp b/3rdparty/boost/boost/config/compiler/diab.hpp index 0de72d06aa..943db83fd6 100644 --- a/3rdparty/boost/boost/config/compiler/diab.hpp +++ b/3rdparty/boost/boost/config/compiler/diab.hpp @@ -12,8 +12,15 @@ #include "boost/config/compiler/common_edg.hpp" -#define BOOST_HAS_LONG_LONG #define BOOST_NO_TWO_PHASE_NAME_LOOKUP +#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS + +#define BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE +#define BOOST_LOG_NO_MEMBER_TEMPLATE_FRIENDS +#define BOOST_REGEX_NO_EXTERNAL_TEMPLATES + #define BOOST_NO_CXX11_HDR_INITIALIZER_LIST #define BOOST_NO_CXX11_HDR_CODECVT +#define BOOST_NO_CXX11_NUMERIC_LIMITS + #define BOOST_COMPILER "Wind River Diab " BOOST_STRINGIZE(__VERSION_NUMBER__) diff --git a/3rdparty/boost/boost/config/compiler/digitalmars.hpp b/3rdparty/boost/boost/config/compiler/digitalmars.hpp index e4c5afddd2..3e9a3ab0f5 100644 --- a/3rdparty/boost/boost/config/compiler/digitalmars.hpp +++ b/3rdparty/boost/boost/config/compiler/digitalmars.hpp @@ -124,6 +124,9 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif #if (__DMC__ <= 0x840) #error "Compiler not supported or configured - please reconfigure" diff --git a/3rdparty/boost/boost/config/compiler/gcc.hpp b/3rdparty/boost/boost/config/compiler/gcc.hpp index d1cfed7a32..19ccc592fd 100644 --- a/3rdparty/boost/boost/config/compiler/gcc.hpp +++ b/3rdparty/boost/boost/config/compiler/gcc.hpp @@ -99,10 +99,10 @@ // Dynamic shared object (DSO) and dynamic-link library (DLL) support // #if __GNUC__ >= 4 -# if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(__CYGWIN__) +# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__) // All Win32 development environments, including 64-bit Windows and MinGW, define // _WIN32 or one of its variant spellings. Note that Cygwin is a POSIX environment, - // so does not define _WIN32 or its variants. + // so does not define _WIN32 or its variants, but still supports dllexport/dllimport. # define BOOST_HAS_DECLSPEC # define BOOST_SYMBOL_EXPORT __attribute__((__dllexport__)) # define BOOST_SYMBOL_IMPORT __attribute__((__dllimport__)) @@ -233,6 +233,7 @@ // #if (BOOST_GCC_VERSION < 40600) || !defined(BOOST_GCC_CXX11) #define BOOST_NO_CXX11_CONSTEXPR +#define BOOST_NO_CXX11_DEFAULTED_MOVES #define BOOST_NO_CXX11_NOEXCEPT #define BOOST_NO_CXX11_NULLPTR #define BOOST_NO_CXX11_RANGE_BASED_FOR @@ -284,7 +285,7 @@ #if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304) # define BOOST_NO_CXX14_CONSTEXPR #endif -#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304) +#if (BOOST_GCC_VERSION < 50200) || !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304) # define BOOST_NO_CXX14_VARIABLE_TEMPLATES #endif @@ -298,6 +299,9 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif #if __GNUC__ >= 7 # define BOOST_FALLTHROUGH __attribute__((fallthrough)) @@ -315,6 +319,10 @@ #if __GNUC__ >= 4 # define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__)) #endif + +// Type aliasing hint. Supported since gcc 3.3. +#define BOOST_MAY_ALIAS __attribute__((__may_alias__)) + // // __builtin_unreachable: #if BOOST_GCC_VERSION >= 40800 @@ -338,10 +346,10 @@ # error "Compiler not configured - please reconfigure" #endif // -// last known and checked version is 4.9: -#if (BOOST_GCC_VERSION > 40900) +// last known and checked version is 7.1: +#if (BOOST_GCC_VERSION > 70100) # if defined(BOOST_ASSERT_CONFIG) -# error "Unknown compiler version - please run the configure tests and report the results" +# error "Boost.Config is older than your compiler - please check for an updated Boost release." # else // we don't emit warnings here anymore since there are no defect macros defined for // gcc post 3.4, so any failures are gcc regressions... diff --git a/3rdparty/boost/boost/config/compiler/gcc_xml.hpp b/3rdparty/boost/boost/config/compiler/gcc_xml.hpp index 2b47585ab8..bdba4ed092 100644 --- a/3rdparty/boost/boost/config/compiler/gcc_xml.hpp +++ b/3rdparty/boost/boost/config/compiler/gcc_xml.hpp @@ -102,6 +102,9 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif #define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__ diff --git a/3rdparty/boost/boost/config/compiler/intel.hpp b/3rdparty/boost/boost/config/compiler/intel.hpp index f55189a0ab..0eea05b916 100644 --- a/3rdparty/boost/boost/config/compiler/intel.hpp +++ b/3rdparty/boost/boost/config/compiler/intel.hpp @@ -45,6 +45,7 @@ #undef BOOST_GCC_VERSION #undef BOOST_GCC_CXX11 +#undef BOOST_GCC // Broken in all versions up to 17 (newer versions not tested) #if (__INTEL_COMPILER <= 1700) && !defined(BOOST_NO_CXX14_CONSTEXPR) @@ -311,6 +312,12 @@ template<> struct assert_intrinsic_wchar_t {}; # define BOOST_SYMBOL_IMPORT # define BOOST_SYMBOL_VISIBLE __attribute__((visibility("default"))) #endif + +// Type aliasing hint +#if defined(__GNUC__) && (BOOST_INTEL_CXX_VERSION >= 1300) +# define BOOST_MAY_ALIAS __attribute__((__may_alias__)) +#endif + // // C++0x features // For each feature we need to check both the Intel compiler version, @@ -545,7 +552,7 @@ template<> struct assert_intrinsic_wchar_t {}; // last known and checked version: #if (BOOST_INTEL_CXX_VERSION > 1700) # if defined(BOOST_ASSERT_CONFIG) -# error "Unknown compiler version - please run the configure tests and report the results" +# error "Boost.Config is older than your compiler - please check for an updated Boost release." # elif defined(_MSC_VER) // // We don't emit this warning any more, since we have so few diff --git a/3rdparty/boost/boost/config/compiler/metrowerks.hpp b/3rdparty/boost/boost/config/compiler/metrowerks.hpp index 99ff0f5eea..4bfc01ece1 100644 --- a/3rdparty/boost/boost/config/compiler/metrowerks.hpp +++ b/3rdparty/boost/boost/config/compiler/metrowerks.hpp @@ -167,6 +167,9 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif #define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) diff --git a/3rdparty/boost/boost/config/compiler/mpw.hpp b/3rdparty/boost/boost/config/compiler/mpw.hpp index d9544345ac..2292ada092 100644 --- a/3rdparty/boost/boost/config/compiler/mpw.hpp +++ b/3rdparty/boost/boost/config/compiler/mpw.hpp @@ -116,6 +116,9 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif // // versions check: diff --git a/3rdparty/boost/boost/config/compiler/nvcc.hpp b/3rdparty/boost/boost/config/compiler/nvcc.hpp index f21b9b54fe..ed035fcf73 100644 --- a/3rdparty/boost/boost/config/compiler/nvcc.hpp +++ b/3rdparty/boost/boost/config/compiler/nvcc.hpp @@ -12,7 +12,7 @@ #endif #if defined(__CUDACC_VER_MAJOR__) && defined(__CUDACC_VER_MINOR__) && defined(__CUDACC_VER_BUILD__) -# define BOOST_CUDA_VERSION __CUDACC_VER_MAJOR__ * 1000000 + __CUDACC_VER_MINOR__ * 10000 + __CUDACC_VER_BUILD__ +# define BOOST_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 1000000 + __CUDACC_VER_MINOR__ * 10000 + __CUDACC_VER_BUILD__) #else // We don't really know what the CUDA version is, but it's definitely before 7.5: # define BOOST_CUDA_VERSION 7000000 @@ -33,8 +33,8 @@ #if (BOOST_CUDA_VERSION > 8000000) && (BOOST_CUDA_VERSION < 8010000) # define BOOST_NO_CXX11_VARIADIC_TEMPLATES #endif -// Most recent CUDA (8.0) has no constexpr support in msvc mode: -#if defined(_MSC_VER) +// CUDA (8.0) has no constexpr support in msvc mode: +#if defined(_MSC_VER) && (BOOST_CUDA_VERSION < 9000000) # define BOOST_NO_CXX11_CONSTEXPR #endif diff --git a/3rdparty/boost/boost/config/compiler/pathscale.hpp b/3rdparty/boost/boost/config/compiler/pathscale.hpp index 94b3f91d07..1318d275ad 100644 --- a/3rdparty/boost/boost/config/compiler/pathscale.hpp +++ b/3rdparty/boost/boost/config/compiler/pathscale.hpp @@ -129,4 +129,7 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif #endif diff --git a/3rdparty/boost/boost/config/compiler/pgi.hpp b/3rdparty/boost/boost/config/compiler/pgi.hpp index 4c402ba0d6..4e909d8a17 100644 --- a/3rdparty/boost/boost/config/compiler/pgi.hpp +++ b/3rdparty/boost/boost/config/compiler/pgi.hpp @@ -1,4 +1,5 @@ // (C) Copyright Noel Belcourt 2007. +// Copyright 2017, NVIDIA CORPORATION. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -10,159 +11,13 @@ #define BOOST_COMPILER_VERSION __PGIC__##__PGIC_MINOR__ #define BOOST_COMPILER "PGI compiler version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) -// -// Threading support: -// Turn this on unconditionally here, it will get turned off again later -// if no threading API is detected. -// +// PGI is mostly GNU compatible. So start with that. +#include -#if __PGIC__ >= 11 +// Now adjust for things that are different. -// options requested by configure --enable-test -#define BOOST_HAS_PTHREADS -#define BOOST_HAS_THREADS -#define BOOST_HAS_PTHREAD_YIELD -#define BOOST_HAS_NRVO -#define BOOST_HAS_LONG_LONG - -// options --enable-test wants undefined -#undef BOOST_NO_STDC_NAMESPACE -#undef BOOST_NO_EXCEPTION_STD_NAMESPACE -#undef BOOST_DEDUCED_TYPENAME - -#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL -#define BOOST_NO_TWO_PHASE_NAME_LOOKUP -#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS -#define BOOST_NO_CXX11_AUTO_DECLARATIONS - -#elif __PGIC__ >= 10 - -// options requested by configure --enable-test -#define BOOST_HAS_THREADS -#define BOOST_HAS_NRVO -#define BOOST_HAS_LONG_LONG -#if defined(linux) || defined(__linux) || defined(__linux__) -# define BOOST_HAS_STDINT_H -#endif - -// options --enable-test wants undefined -#undef BOOST_NO_STDC_NAMESPACE -#undef BOOST_NO_EXCEPTION_STD_NAMESPACE -#undef BOOST_DEDUCED_TYPENAME - -#elif __PGIC__ >= 7 - -#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL -#define BOOST_NO_TWO_PHASE_NAME_LOOKUP -#define BOOST_NO_SWPRINTF -#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS -#define BOOST_NO_CXX11_AUTO_DECLARATIONS - -#else - -# error "Pgi compiler not configured - please reconfigure" - -#endif -// -// C++0x features -// -// See boost\config\suffix.hpp for BOOST_NO_LONG_LONG -// -#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_EXTERN_TEMPLATE -#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_NUMERIC_LIMITS -#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_SWPRINTF -#define BOOST_NO_CXX11_TEMPLATE_ALIASES -#define BOOST_NO_CXX11_UNICODE_LITERALS -#define BOOST_NO_CXX11_VARIADIC_TEMPLATES -#define BOOST_NO_CXX11_VARIADIC_MACROS -#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX - -#define BOOST_NO_CXX11_HDR_UNORDERED_SET -#define BOOST_NO_CXX11_HDR_UNORDERED_MAP -#define BOOST_NO_CXX11_HDR_TYPEINDEX -#define BOOST_NO_CXX11_HDR_TYPE_TRAITS -#define BOOST_NO_CXX11_HDR_TUPLE -#define BOOST_NO_CXX11_HDR_THREAD -#define BOOST_NO_CXX11_HDR_SYSTEM_ERROR -#define BOOST_NO_CXX11_HDR_REGEX -#define BOOST_NO_CXX11_HDR_RATIO -#define BOOST_NO_CXX11_HDR_RANDOM -#define BOOST_NO_CXX11_HDR_MUTEX -#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST -#define BOOST_NO_CXX11_HDR_FUTURE -#define BOOST_NO_CXX11_HDR_FORWARD_LIST -#define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE -#define BOOST_NO_CXX11_HDR_CODECVT -#define BOOST_NO_CXX11_HDR_CHRONO -#define BOOST_NO_CXX11_HDR_ARRAY -#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_THREAD_LOCAL - -// C++ 14: -#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304) -# define BOOST_NO_CXX14_AGGREGATE_NSDMI -#endif -#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304) -# define BOOST_NO_CXX14_BINARY_LITERALS -#endif -#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304) -# define BOOST_NO_CXX14_CONSTEXPR -#endif -#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304) -# define BOOST_NO_CXX14_DECLTYPE_AUTO -#endif -#if (__cplusplus < 201304) // There's no SD6 check for this.... -# define BOOST_NO_CXX14_DIGIT_SEPARATORS -#endif -#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304) -# define BOOST_NO_CXX14_GENERIC_LAMBDAS -#endif -#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304) -# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES -#endif -#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304) -# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION -#endif -#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304) -# define BOOST_NO_CXX14_VARIABLE_TEMPLATES -#endif - -// C++17 -#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606) -# define BOOST_NO_CXX17_STRUCTURED_BINDINGS -#endif -#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606) -# define BOOST_NO_CXX17_INLINE_VARIABLES -#endif -#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) -# define BOOST_NO_CXX17_FOLD_EXPRESSIONS -#endif -// -// version check: -// probably nothing to do here? +// __float128 is a typedef, not a distinct type. +#undef BOOST_HAS_FLOAT128 +// __int128 is not supported. +#undef BOOST_HAS_INT128 diff --git a/3rdparty/boost/boost/config/compiler/sunpro_cc.hpp b/3rdparty/boost/boost/config/compiler/sunpro_cc.hpp index 2453e7cfc1..41b7bcade6 100644 --- a/3rdparty/boost/boost/config/compiler/sunpro_cc.hpp +++ b/3rdparty/boost/boost/config/compiler/sunpro_cc.hpp @@ -182,6 +182,9 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif // Turn on threading support for Solaris 12. // Ticket #11972 @@ -202,9 +205,9 @@ #error "Compiler not supported or configured - please reconfigure" #endif // -// last known and checked version is 0x590: -#if (__SUNPRO_CC > 0x590) +// last known and checked version: +#if (__SUNPRO_CC > 0x5150) # if defined(BOOST_ASSERT_CONFIG) -# error "Unknown compiler version - please run the configure tests and report the results" +# error "Boost.Config is older than your compiler - please check for an updated Boost release." # endif #endif diff --git a/3rdparty/boost/boost/config/compiler/vacpp.hpp b/3rdparty/boost/boost/config/compiler/vacpp.hpp index 683c167dbf..cabe844ffd 100644 --- a/3rdparty/boost/boost/config/compiler/vacpp.hpp +++ b/3rdparty/boost/boost/config/compiler/vacpp.hpp @@ -65,6 +65,11 @@ #define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS #endif +// Type aliasing hint. Supported since XL C++ 13.1 +#if (__IBMCPP__ >= 1310) +# define BOOST_MAY_ALIAS __attribute__((__may_alias__)) +#endif + // // C++0x features // @@ -173,3 +178,6 @@ #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) # define BOOST_NO_CXX17_FOLD_EXPRESSIONS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif diff --git a/3rdparty/boost/boost/config/compiler/visualc.hpp b/3rdparty/boost/boost/config/compiler/visualc.hpp index 7df92ba31b..ded7284a62 100644 --- a/3rdparty/boost/boost/config/compiler/visualc.hpp +++ b/3rdparty/boost/boost/config/compiler/visualc.hpp @@ -167,6 +167,7 @@ // #if (_MSC_FULL_VER < 190023026) # define BOOST_NO_CXX11_NOEXCEPT +# define BOOST_NO_CXX11_DEFAULTED_MOVES # define BOOST_NO_CXX11_REF_QUALIFIERS # define BOOST_NO_CXX11_USER_DEFINED_LITERALS # define BOOST_NO_CXX11_ALIGNAS @@ -200,6 +201,7 @@ // #if (_MSC_VER < 1911) || (_MSVC_LANG < 201703) # define BOOST_NO_CXX17_STRUCTURED_BINDINGS +# define BOOST_NO_CXX17_IF_CONSTEXPR #endif // MSVC including version 14 has not yet completely @@ -217,17 +219,29 @@ // https://connect.microsoft.com/VisualStudio/feedback/details/1582233/c-subobjects-still-not-value-initialized-correctly // See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues // (Niels Dekker, LKEB, May 2010) +// Still present in VC15.5, Dec 2017. #define BOOST_NO_COMPLETE_VALUE_INITIALIZATION // // C++ 11: // -#define BOOST_NO_TWO_PHASE_NAME_LOOKUP +// This is supported with /permissive- for 15.5 onwards, unfortunately we appear to have no way to tell +// 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: +// +# define BOOST_NO_TWO_PHASE_NAME_LOOKUP + +#if (_MSC_VER < 1912) || (_MSVC_LANG < 201402) +// Supported from msvc-15.5 onwards: #define BOOST_NO_CXX11_SFINAE_EXPR +#endif // C++ 14: +// Still gives internal compiler error for msvc-15.5: # define BOOST_NO_CXX14_CONSTEXPR // C++ 17: +#if (_MSC_VER < 1912) || (_MSVC_LANG < 201703) #define BOOST_NO_CXX17_INLINE_VARIABLES #define BOOST_NO_CXX17_FOLD_EXPRESSIONS +#endif // // Things that don't work in clr mode: @@ -294,7 +308,7 @@ # endif # endif # else -# if _MSC_VER < 1310 +# if _MSC_VER < 1200 // Note: Versions up to 7.0 aren't supported. # define BOOST_COMPILER_VERSION 5.0 # elif _MSC_VER < 1300 @@ -325,12 +339,17 @@ # define BOOST_COMPILER "Microsoft Visual C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) #endif +#include + // -// last known and checked version is 19.11.25506 (VC++ 2017.3): -#if (_MSC_VER > 1911) +// last known and checked version is 19.12.25830.2 (VC++ 2017.3): +#if (_MSC_VER > 1912) # if defined(BOOST_ASSERT_CONFIG) -# error "Unknown compiler version - please run the configure tests and report the results" -# else -# pragma message("Unknown compiler version - please run the configure tests and report the results") +# error "Boost.Config is older than your current compiler version." +# elif !defined(BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE) + // + // Disabled as of March 2018 - the pace of VS releases is hard to keep up with + // and in any case, we have relatively few defect macros defined now. + // BOOST_PRAGMA_MESSAGE("Info: Boost.Config is older than your compiler version - probably nothing bad will happen - but you may wish to look for an updated Boost version. Define BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE to suppress this message.") # endif #endif diff --git a/3rdparty/boost/boost/config/compiler/xlcpp.hpp b/3rdparty/boost/boost/config/compiler/xlcpp.hpp index b267f49bad..ee7aa1253a 100644 --- a/3rdparty/boost/boost/config/compiler/xlcpp.hpp +++ b/3rdparty/boost/boost/config/compiler/xlcpp.hpp @@ -246,6 +246,10 @@ # define BOOST_NO_CXX17_STRUCTURED_BINDINGS #endif +#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606) +# define BOOST_NO_CXX17_IF_CONSTEXPR +#endif + // Clang 3.9+ in c++1z #if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L # define BOOST_NO_CXX17_INLINE_VARIABLES @@ -267,6 +271,11 @@ # define BOOST_ATTRIBUTE_UNUSED __attribute__((unused)) #endif +// Type aliasing hint. +#if __has_attribute(__may_alias__) +# define BOOST_MAY_ALIAS __attribute__((__may_alias__)) +#endif + #ifndef BOOST_COMPILER # define BOOST_COMPILER "Clang version " __clang_version__ #endif diff --git a/3rdparty/boost/boost/config/compiler/xlcpp_zos.hpp b/3rdparty/boost/boost/config/compiler/xlcpp_zos.hpp index c554903a0b..eb1bf2e992 100644 --- a/3rdparty/boost/boost/config/compiler/xlcpp_zos.hpp +++ b/3rdparty/boost/boost/config/compiler/xlcpp_zos.hpp @@ -153,12 +153,14 @@ #define BOOST_NO_CXX17_STRUCTURED_BINDINGS #define BOOST_NO_CXX17_INLINE_VARIABLES #define BOOST_NO_CXX17_FOLD_EXPRESSIONS +#define BOOST_NO_CXX17_IF_CONSTEXPR // ------------------------------------- #if defined(__IBM_ATTRIBUTES) # define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__)) # define BOOST_NOINLINE __attribute__ ((__noinline__)) +# define BOOST_MAY_ALIAS __attribute__((__may_alias__)) // No BOOST_ALIGNMENT - explicit alignment support is broken (V2R1). #endif diff --git a/3rdparty/boost/boost/config/detail/select_compiler_config.hpp b/3rdparty/boost/boost/config/detail/select_compiler_config.hpp index 97d47c1c56..ced8443da9 100644 --- a/3rdparty/boost/boost/config/detail/select_compiler_config.hpp +++ b/3rdparty/boost/boost/config/detail/select_compiler_config.hpp @@ -52,6 +52,10 @@ // Wind River Diab C++ # define BOOST_COMPILER_CONFIG "boost/config/compiler/diab.hpp" +#elif defined(__PGI) +// Portland Group Inc. +# define BOOST_COMPILER_CONFIG "boost/config/compiler/pgi.hpp" + # elif defined(__GNUC__) && !defined(__ibmxl__) // GNU C++: # define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp" @@ -108,10 +112,6 @@ // IBM Visual Age or IBM XL C/C++ for Linux (Big Endian) # define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp" -#elif defined(__PGI) -// Portland Group Inc. -# define BOOST_COMPILER_CONFIG "boost/config/compiler/pgi.hpp" - #elif defined _MSC_VER // Microsoft Visual C++ // diff --git a/3rdparty/boost/boost/config/detail/suffix.hpp b/3rdparty/boost/boost/config/detail/suffix.hpp index 6abec22f58..22d31f68db 100644 --- a/3rdparty/boost/boost/config/detail/suffix.hpp +++ b/3rdparty/boost/boost/config/detail/suffix.hpp @@ -537,25 +537,10 @@ namespace std{ using ::type_info; } // ---------------------------------------------------------------------------// -// // Helper macro BOOST_STRINGIZE: -// Converts the parameter X to a string after macro replacement -// on X has been performed. -// -#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) -#define BOOST_DO_STRINGIZE(X) #X - -// // Helper macro BOOST_JOIN: -// The following piece of macro magic joins the two -// arguments together, even when one of the arguments is -// itself a macro (see 16.3.1 in C++ standard). The key -// is that macro expansion of macro arguments does not -// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN. -// -#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y ) -#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y) -#define BOOST_DO_JOIN2( X, Y ) X##Y + +#include // // Set some default values for compiler/library/platform names. @@ -602,6 +587,14 @@ namespace std{ using ::type_info; } # endif #endif +// BOOST_MAY_ALIAS -----------------------------------------------// +// The macro expands to an attribute to mark a type that is allowed to alias other types. +// The macro is defined in the compiler-specific headers. +#if !defined(BOOST_MAY_ALIAS) +# define BOOST_NO_MAY_ALIAS +# define BOOST_MAY_ALIAS +#endif + // BOOST_FORCEINLINE ---------------------------------------------// // Macro to use in place of 'inline' to force a function to be inline #if !defined(BOOST_FORCEINLINE) @@ -694,6 +687,11 @@ namespace std{ using ::type_info; } # define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS #endif +// Lack of defaulted moves is implied by the lack of either rvalue references or any defaulted functions +#if !defined(BOOST_NO_CXX11_DEFAULTED_MOVES) && (defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES)) +# define BOOST_NO_CXX11_DEFAULTED_MOVES +#endif + // Defaulted and deleted function declaration helpers // These macros are intended to be inside a class definition. // BOOST_DEFAULTED_FUNCTION accepts the function declaration and its diff --git a/3rdparty/boost/boost/config/header_deprecated.hpp b/3rdparty/boost/boost/config/header_deprecated.hpp new file mode 100644 index 0000000000..864554f2a2 --- /dev/null +++ b/3rdparty/boost/boost/config/header_deprecated.hpp @@ -0,0 +1,26 @@ +#ifndef BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED +#define BOOST_CONFIG_HEADER_DEPRECATED_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 +// +// BOOST_HEADER_DEPRECATED("") +// +// Expands to the equivalent of +// BOOST_PRAGMA_MESSAGE("This header is deprecated. Use instead.") +// +// Note that this header is C compatible. + +#include + +#if defined(BOOST_ALLOW_DEPRECATED_HEADERS) +# define BOOST_HEADER_DEPRECATED(a) +#else +# define BOOST_HEADER_DEPRECATED(a) BOOST_PRAGMA_MESSAGE("This header is deprecated. Use " a " instead.") +#endif + +#endif // BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED diff --git a/3rdparty/boost/boost/config/helper_macros.hpp b/3rdparty/boost/boost/config/helper_macros.hpp new file mode 100644 index 0000000000..3e79526df6 --- /dev/null +++ b/3rdparty/boost/boost/config/helper_macros.hpp @@ -0,0 +1,37 @@ +#ifndef BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED +#define BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED + +// Copyright 2001 John Maddock. +// 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 +// +// BOOST_STRINGIZE(X) +// BOOST_JOIN(X, Y) +// +// Note that this header is C compatible. + +// +// Helper macro BOOST_STRINGIZE: +// Converts the parameter X to a string after macro replacement +// on X has been performed. +// +#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) +#define BOOST_DO_STRINGIZE(X) #X + +// +// Helper macro BOOST_JOIN: +// The following piece of macro magic joins the two +// arguments together, even when one of the arguments is +// itself a macro (see 16.3.1 in C++ standard). The key +// is that macro expansion of macro arguments does not +// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN. +// +#define BOOST_JOIN(X, Y) BOOST_DO_JOIN(X, Y) +#define BOOST_DO_JOIN(X, Y) BOOST_DO_JOIN2(X,Y) +#define BOOST_DO_JOIN2(X, Y) X##Y + +#endif // BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED diff --git a/3rdparty/boost/boost/config/platform/cygwin.hpp b/3rdparty/boost/boost/config/platform/cygwin.hpp index 8ecc4a4af5..6dd7e57cfd 100644 --- a/3rdparty/boost/boost/config/platform/cygwin.hpp +++ b/3rdparty/boost/boost/config/platform/cygwin.hpp @@ -38,10 +38,21 @@ #ifdef _STDINT_H #define BOOST_HAS_STDINT_H #endif +#if __GNUC__ > 5 && !defined(BOOST_HAS_STDINT_H) +# define BOOST_HAS_STDINT_H +#endif /// Cygwin has no fenv.h #define BOOST_NO_FENV_H +// Cygwin has it's own which breaks unless the correct compiler flags are used: +#ifndef BOOST_NO_CXX14_HDR_SHARED_MUTEX +#include +#if !(__XSI_VISIBLE >= 500 || __POSIX_VISIBLE >= 200112) +# define BOOST_NO_CXX14_HDR_SHARED_MUTEX +#endif +#endif + // boilerplate code: #include diff --git a/3rdparty/boost/boost/config/platform/vxworks.hpp b/3rdparty/boost/boost/config/platform/vxworks.hpp index a7f571c499..a91e4ab439 100644 --- a/3rdparty/boost/boost/config/platform/vxworks.hpp +++ b/3rdparty/boost/boost/config/platform/vxworks.hpp @@ -1,30 +1,50 @@ // (C) Copyright Dustin Spicuzza 2009. // Adapted to vxWorks 6.9 by Peter Brockamp 2012. +// Updated for VxWorks 7 by Brian Kuhl 2016 // 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. -// Since WRS does not yet properly support boost under vxWorks -// and this file was badly outdated, but I was keen on using it, -// I patched boost myself to make things work. This has been tested -// and adapted by me for vxWorks 6.9 *only*, as I'm lacking access -// to earlier 6.X versions! The only thing I know for sure is that -// very old versions of vxWorks (namely everything below 6.x) are -// absolutely unable to use boost. This is mainly due to the completely -// outdated libraries and ancient compiler (GCC 2.96 or worse). Do -// not even think of getting this to work, a miserable failure will -// be guaranteed! +// Old versions of vxWorks (namely everything below 6.x) are +// absolutely unable to use boost. Old STLs and compilers +// like (GCC 2.96) . Do not even think of getting this to work, +// a miserable failure will be guaranteed! +// // Equally, this file has been tested for RTPs (Real Time Processes) // only, not for DKMs (Downloadable Kernel Modules). These two types // of executables differ largely in the available functionality of -// the C-library, STL, and so on. A DKM uses a library similar to those -// of vxWorks 5.X - with all its limitations and incompatibilities -// with respect to ANSI C++ and STL. So probably there might be problems -// with the usage of boost from DKMs. WRS or any voluteers are free to -// prove the opposite! - +// the C-library, STL, and so on. A DKM uses a C89 library with no +// wide character support and no guarantee of ANSI C. The same Dinkum +// STL library is used in both contexts. +// +// Similarly the Dinkum abridged STL that supports the loosely specified +// embedded C++ standard has not been tested and is unlikely to work +// on anything but the simplest library. +// ==================================================================== +// +// Additional Configuration +// ------------------------------------------------------------------- +// +// Because of the ordering of include files and other issues the following +// additional definitions worked better outside this file. +// +// When building the log library add the following to the b2 invocation +// define=BOOST_LOG_WITHOUT_IPC +// and +// -DBOOST_LOG_WITHOUT_DEFAULT_FACTORIES +// to your compile options. +// +// When building the test library add +// -DBOOST_TEST_LIMITED_SIGNAL_DETAILS +// to your compile options +// +// When building containers library add +// -DHAVE_MORECORE=0 +// to your c compile options so dlmalloc heap library is compiled +// without brk() calls +// // ==================================================================== // // Some important information regarding the usage of POSIX semaphores: @@ -38,29 +58,14 @@ // Now, VxWorks POSIX-semaphores for DKM's default to the usage of // priority inverting semaphores, which is fine. On the other hand, // for RTP's it defaults to using non priority inverting semaphores, -// which could easily pose a serious problem for a real time process, -// i.e. deadlocks! To overcome this two possibilities do exist: -// -// a) Patch every piece of boost that uses semaphores to instanciate -// the proper type of semaphores. This is non-intrusive with respect -// to the OS and could relatively easy been done by giving all -// semaphores attributes deviating from the default (for in-depth -// information see the POSIX functions pthread_mutexattr_init() -// and pthread_mutexattr_setprotocol()). However this breaks all -// too easily, as with every new version some boost library could -// all in a sudden start using semaphores, resurrecting the very -// same, hard to locate problem over and over again! +// which could easily pose a serious problem for a real time process. // -// b) We could change the default properties for POSIX-semaphores -// that VxWorks uses for RTP's and this is being suggested here, -// as it will more or less seamlessly integrate with boost. I got -// the following information from WRS how to do this, compare -// Wind River TSR# 1209768: -// -// Instructions for changing the default properties of POSIX- -// semaphores for RTP's in VxWorks 6.9: -// - Edit the file /vxworks-6.9/target/usr/src/posix/pthreadLib.c -// in the root of your Workbench-installation. +// To change the default properties for POSIX-semaphores in VxWorks 7 +// enable core > CORE_USER Menu > DEFAULT_PTHREAD_PRIO_INHERIT +// +// In VxWorks 6.x so as to integrate with boost. +// - Edit the file +// installDir/vxworks-6.x/target/usr/src/posix/pthreadLib.c // - Around line 917 there should be the definition of the default // mutex attributes: // @@ -81,30 +86,11 @@ // pAttr->mutexAttrType = PTHREAD_MUTEX_DEFAULT; // // Here again, replace PTHREAD_PRIO_NONE by PTHREAD_PRIO_INHERIT. -// - Finally, rebuild your VSB. This will create a new VxWorks kernel +// - Finally, rebuild your VSB. This will rebuild the libraries // with the changed properties. That's it! Now, using boost should // no longer cause any problems with task deadlocks! // -// And here's another useful piece of information concerning VxWorks' -// POSIX-functionality in general: -// VxWorks is not a genuine POSIX-OS in itself, rather it is using a -// kind of compatibility layer (sort of a wrapper) to emulate the -// POSIX-functionality by using its own resources and functions. -// At the time a task (thread) calls it's first POSIX-function during -// runtime it is being transformed by the OS into a POSIX-thread. -// This transformation does include a call to malloc() to allocate the -// memory required for the housekeeping of POSIX-threads. In a high -// priority RTP this malloc() call may be highly undesirable, as its -// timing is more or less unpredictable (depending on what your actual -// heap looks like). You can circumvent this problem by calling the -// function thread_self() at a well defined point in the code of the -// task, e.g. shortly after the task spawns up. Thereby you are able -// to define the time when the task-transformation will take place and -// you could shift it to an uncritical point where a malloc() call is -// tolerable. So, if this could pose a problem for your code, remember -// to call thread_self() from the affected task at an early stage. -// -// ==================================================================== +// ==================================================================== // Block out all versions before vxWorks 6.x, as these don't work: // Include header with the vxWorks version information and query them @@ -158,11 +144,6 @@ #define BOOST_HAS_CLOCK_GETTIME #define BOOST_HAS_MACRO_USE_FACET -// Generally unavailable functionality, delivered by boost's test function: -//#define BOOST_NO_DEDUCED_TYPENAME // Commented this out, boost's test gives an errorneous result! -#define BOOST_NO_CXX11_EXTERN_TEMPLATE -#define BOOST_NO_CXX11_VARIADIC_MACROS - // Generally available threading API's: #define BOOST_HAS_PTHREADS #define BOOST_HAS_SCHED_YIELD @@ -191,14 +172,7 @@ # endif #endif -// vxWorks doesn't work with asio serial ports: -#define BOOST_ASIO_DISABLE_SERIAL_PORT -// TODO: The problem here seems to bee that vxWorks uses its own, very specific -// ways to handle serial ports, incompatible with POSIX or anything... -// Maybe a specific implementation would be possible, but until the -// straight need arises... This implementation would presumably consist -// of some vxWorks specific ioctl-calls, etc. Any voluteers? - +#if (_WRS_VXWORKS_MAJOR < 7) // vxWorks-around: #defines CLOCKS_PER_SEC as sysClkRateGet() but // miserably fails to #include the required to make // sysClkRateGet() available! So we manually include it here. @@ -208,11 +182,12 @@ #endif // vxWorks-around: In the macros INT32_C(), UINT32_C(), INT64_C() and -// UINT64_C() are defined errorneously, yielding not a signed/ +// UINT64_C() are defined erroneously, yielding not a signed/ // unsigned long/long long type, but a signed/unsigned int/long // type. Eventually this leads to compile errors in ratio_fwd.hpp, // when trying to define several constants which do not fit into a // long type! We correct them here by redefining. + #include // Some macro-magic to do the job @@ -231,12 +206,16 @@ #define UINT64_C(x) VX_JOIN(x, ULL) // #include Libraries required for the following function adaption +#include +#endif // _WRS_VXWORKS_MAJOR < 7 + #include #include -#include // Use C-linkage for the following helper functions +#ifdef __cplusplus extern "C" { +#endif // vxWorks-around: The required functions getrlimit() and getrlimit() are missing. // But we have the similar functions getprlimit() and setprlimit(), @@ -248,7 +227,7 @@ extern "C" { // TODO: getprlimit() and setprlimit() do exist for RTPs only, for whatever reason. // Thus for DKMs there would have to be another implementation. -#ifdef __RTP__ +#if defined ( __RTP__) && (_WRS_VXWORKS_MAJOR < 7) inline int getrlimit(int resource, struct rlimit *rlp){ return getprlimit(0, 0, resource, rlp); } @@ -273,14 +252,20 @@ inline int truncate(const char *p, off_t l){ return close(fd); } +#ifdef __GNUC__ +#define ___unused __attribute__((unused)) +#else +#define ___unused +#endif + // Fake symlink handling by dummy functions: -inline int symlink(const char*, const char*){ +inline int symlink(const char* path1 ___unused, const char* path2 ___unused){ // vxWorks has no symlinks -> always return an error! errno = EACCES; return -1; } -inline ssize_t readlink(const char*, char*, size_t){ +inline ssize_t readlink(const char* path1 ___unused, char* path2 ___unused, size_t size ___unused){ // vxWorks has no symlinks -> always return an error! errno = EACCES; return -1; @@ -297,8 +282,18 @@ inline int gettimeofday(struct timeval *tv, void * /*tzv*/) { } #endif +#ifdef __cplusplus +} // extern "C" +#endif -// vxWorks does provide neither struct tms nor function times()! +/* + * moved to os/utils/unix/freind_h/times.h in VxWorks 7 + * to avoid conflict with MPL operator times + */ +#if (_WRS_VXWORKS_MAJOR < 7) +#ifdef __cplusplus + +// vxWorks provides neither struct tms nor function times()! // We implement an empty dummy-function, simply setting the user // and system time to the half of thew actual system ticks-value // and the child user and system time to 0. @@ -315,7 +310,8 @@ struct tms{ clock_t tms_cstime; // System CPU time of terminated child processes }; -inline clock_t times(struct tms *t){ + + inline clock_t times(struct tms *t){ struct timespec ts; clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts); clock_t ticks(static_cast(static_cast(ts.tv_sec) * CLOCKS_PER_SEC + @@ -327,8 +323,16 @@ inline clock_t times(struct tms *t){ return ticks; } -extern void bzero (void *, size_t); // FD_ZERO uses bzero() but doesn't include strings.h -} // extern "C" + +namespace std { + using ::times; +} +#endif // __cplusplus +#endif // _WRS_VXWORKS_MAJOR < 7 + + +#ifdef __cplusplus +extern "C" void bzero (void *, size_t); // FD_ZERO uses bzero() but doesn't include strings.h // Put the selfmade functions into the std-namespace, just in case namespace std { @@ -339,9 +343,11 @@ namespace std { using ::truncate; using ::symlink; using ::readlink; - using ::times; - using ::gettimeofday; +#if (_WRS_VXWORKS_MAJOR < 7) + using ::gettimeofday; +#endif } +#endif // __cplusplus // Some more macro-magic: // vxWorks-around: Some functions are not present or broken in vxWorks @@ -349,12 +355,13 @@ namespace std { // Include signal.h which might contain a typo to be corrected here #include - -inline int getpagesize() { return sysconf(_SC_PAGESIZE); } // getpagesize is deprecated anyway! +#if (_WRS_VXWORKS_MAJOR < 7) +#define getpagesize() sysconf(_SC_PAGESIZE) // getpagesize is deprecated anyway! +inline int lstat(p, b) { return stat(p, b); } // lstat() == stat(), as vxWorks has no symlinks! +#endif #ifndef S_ISSOCK # define S_ISSOCK(mode) ((mode & S_IFMT) == S_IFSOCK) // Is file a socket? #endif -inline int lstat(p, b) { return stat(p, b); } // lstat() == stat(), as vxWorks has no symlinks! #ifndef FPE_FLTINV # define FPE_FLTINV (FPE_FLTSUB+1) // vxWorks has no FPE_FLTINV, so define one as a dummy #endif @@ -371,22 +378,56 @@ typedef int locale_t; // locale_t is a POSIX-ex // vxWorks 7 adds C++11 support // however it is optional, and does not match exactly the support determined -// by examining Dinkum STL version and GCC version (or ICC and DCC) - +// by examining the Dinkum STL version and GCC version (or ICC and DCC) #ifndef _WRS_CONFIG_LANG_LIB_CPLUS_CPLUS_USER_2011 -# define BOOST_NO_CXX11_HDR_ARRAY -# define BOOST_NO_CXX11_HDR_TYPEINDEX -# define BOOST_NO_CXX11_HDR_TYPE_TRAITS -# define BOOST_NO_CXX11_HDR_TUPLE +# define BOOST_NO_CXX11_ADDRESSOF // C11 addressof operator on memory location # define BOOST_NO_CXX11_ALLOCATOR +# define BOOST_NO_CXX11_ATOMIC_SMART_PTR +# define BOOST_NO_CXX11_NUMERIC_LIMITS // max_digits10 in test/../print_helper.hpp # define BOOST_NO_CXX11_SMART_PTR # define BOOST_NO_CXX11_STD_ALIGN -# define BOOST_NO_CXX11_HDR_UNORDERED_SET + + +# define BOOST_NO_CXX11_HDR_ARRAY +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_HDR_CHRONO +# define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE +# define BOOST_NO_CXX11_HDR_FORWARD_LIST //serialization/test/test_list.cpp +# define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_HDR_FUTURE +# define BOOST_NO_CXX11_HDR_MUTEX +# define BOOST_NO_CXX11_HDR_RANDOM //math/../test_data.hpp +# define BOOST_NO_CXX11_HDR_RATIO +# define BOOST_NO_CXX11_HDR_REGEX +# define BOOST_NO_CXX14_HDR_SHARED_MUTEX +# define BOOST_NO_CXX11_HDR_SYSTEM_ERROR +# define BOOST_NO_CXX11_HDR_THREAD +# define BOOST_NO_CXX11_HDR_TYPEINDEX # define BOOST_NO_CXX11_HDR_TYPE_TRAITS +# define BOOST_NO_CXX11_HDR_TUPLE # define BOOST_NO_CXX11_HDR_UNORDERED_MAP -# define BOOST_NO_CXX11_HDR_FUNCTIONAL -# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_HDR_UNORDERED_SET #else -# define BOOST_NO_CXX11_NULLPTR +#ifndef BOOST_SYSTEM_NO_DEPRECATED +# define BOOST_SYSTEM_NO_DEPRECATED // workaround link error in spirit #endif +#endif + + +// NONE is used in enums in lamda and other libraries +#undef NONE +// restrict is an iostreams class +#undef restrict + +// use fake poll() from Unix layer in ASIO to get full functionality +// most libraries will use select() but this define allows 'iostream' functionality +// which is based on poll() only +#if (_WRS_VXWORKS_MAJOR > 6) +# ifndef BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR +# define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR +# endif +#else +# define BOOST_ASIO_DISABLE_SERIAL_PORT +#endif + diff --git a/3rdparty/boost/boost/config/pragma_message.hpp b/3rdparty/boost/boost/config/pragma_message.hpp new file mode 100644 index 0000000000..b2c5ff2e86 --- /dev/null +++ b/3rdparty/boost/boost/config/pragma_message.hpp @@ -0,0 +1,31 @@ +#ifndef BOOST_CONFIG_PRAGMA_MESSAGE_HPP_INCLUDED +#define BOOST_CONFIG_PRAGMA_MESSAGE_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 +// +// BOOST_PRAGMA_MESSAGE("message") +// +// Expands to the equivalent of #pragma message("message") +// +// Note that this header is C compatible. + +#include + +#if defined(BOOST_DISABLE_PRAGMA_MESSAGE) +# define BOOST_PRAGMA_MESSAGE(x) +#elif defined(__INTEL_COMPILER) +# define BOOST_PRAGMA_MESSAGE(x) __pragma(message(__FILE__ "(" BOOST_STRINGIZE(__LINE__) "): note: " x)) +#elif defined(__GNUC__) +# define BOOST_PRAGMA_MESSAGE(x) _Pragma(BOOST_STRINGIZE(message(x))) +#elif defined(_MSC_VER) +# define BOOST_PRAGMA_MESSAGE(x) __pragma(message(__FILE__ "(" BOOST_STRINGIZE(__LINE__) "): note: " x)) +#else +# define BOOST_PRAGMA_MESSAGE(x) +#endif + +#endif // BOOST_CONFIG_PRAGMA_MESSAGE_HPP_INCLUDED diff --git a/3rdparty/boost/boost/config/stdlib/dinkumware.hpp b/3rdparty/boost/boost/config/stdlib/dinkumware.hpp index daac5dfb43..e829f08e51 100644 --- a/3rdparty/boost/boost/config/stdlib/dinkumware.hpp +++ b/3rdparty/boost/boost/config/stdlib/dinkumware.hpp @@ -96,7 +96,8 @@ #include #endif #include -#if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (!_HAS_NAMESPACE && defined(__ghs__)) ) && !defined(__TI_COMPILER_VERSION__) && !defined(__VISUALDSPVERSION__) +#if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (defined(__ghs__) && !_HAS_NAMESPACE) ) && !defined(__TI_COMPILER_VERSION__) && !defined(__VISUALDSPVERSION__) \ + && !defined(__VXWORKS__) # define BOOST_NO_STD_TYPEINFO #endif @@ -172,11 +173,17 @@ // C++17 features #if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) || !defined(BOOST_MSVC) || (BOOST_MSVC < 1910) || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0) # define BOOST_NO_CXX17_STD_APPLY +# define BOOST_NO_CXX17_ITERATOR_TRAITS #endif -#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) +#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 +#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 +#endif + #if defined(BOOST_INTEL) && (BOOST_INTEL <= 1400) // Intel's compiler can't handle this header yet: # define BOOST_NO_CXX11_HDR_ATOMIC diff --git a/3rdparty/boost/boost/config/stdlib/libcomo.hpp b/3rdparty/boost/boost/config/stdlib/libcomo.hpp index ce83f082cc..75ac2bb76a 100644 --- a/3rdparty/boost/boost/config/stdlib/libcomo.hpp +++ b/3rdparty/boost/boost/config/stdlib/libcomo.hpp @@ -79,6 +79,7 @@ // C++17 features # define BOOST_NO_CXX17_STD_APPLY # define BOOST_NO_CXX17_STD_INVOKE +# define BOOST_NO_CXX17_ITERATOR_TRAITS // // Intrinsic type_traits support. diff --git a/3rdparty/boost/boost/config/stdlib/libcpp.hpp b/3rdparty/boost/boost/config/stdlib/libcpp.hpp index 9c58965f80..a051dbb750 100644 --- a/3rdparty/boost/boost/config/stdlib/libcpp.hpp +++ b/3rdparty/boost/boost/config/stdlib/libcpp.hpp @@ -87,9 +87,6 @@ #endif // C++17 features -#if (_LIBCPP_VERSION < 3700) || (__cplusplus <= 201402L) -# define BOOST_NO_CXX17_STD_INVOKE -#endif #if (_LIBCPP_VERSION < 4000) || (__cplusplus <= 201402L) # define BOOST_NO_CXX17_STD_APPLY #endif @@ -103,6 +100,9 @@ # define BOOST_NO_CXX98_BINDERS #endif +#define BOOST_NO_CXX17_ITERATOR_TRAITS +#define BOOST_NO_CXX17_STD_INVOKE // Invoke support is incomplete (no invoke_result) + #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 // support for thread_local, leading to linker errors such as @@ -111,6 +111,13 @@ # define BOOST_NO_CXX11_THREAD_LOCAL #endif +#if defined(__linux__) && !defined(BOOST_NO_CXX11_THREAD_LOCAL) +// After libc++-dev is installed on Trusty, clang++-libc++ almost works, +// except uses of `thread_local` fail with undefined reference to +// `__cxa_thread_atexit`. +# define BOOST_NO_CXX11_THREAD_LOCAL +#endif + #if defined(__has_include) #if !__has_include() # define BOOST_NO_CXX14_HDR_SHARED_MUTEX diff --git a/3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp b/3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp index 9adbc8f171..f6eab26c65 100644 --- a/3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp +++ b/3rdparty/boost/boost/config/stdlib/libstdcpp3.hpp @@ -78,6 +78,7 @@ # include #endif +#ifndef __VXWORKS__ // VxWorks uses Dinkum, not GNU STL with GCC #if defined(__GLIBCXX__) || (defined(__GLIBCPP__) && __GLIBCPP__>=20020514) // GCC >= 3.1.0 # define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx # define BOOST_HAS_SLIST @@ -91,6 +92,7 @@ # define BOOST_HASH_MAP_HEADER # endif #endif +#endif // // Decide whether we have C++11 support turned on: @@ -247,6 +249,7 @@ extern "C" char *gets (char *__s); #if (BOOST_LIBSTDCXX_VERSION < 40600) || !defined(BOOST_LIBSTDCXX11) # define BOOST_NO_CXX11_HDR_TYPEINDEX # define BOOST_NO_CXX11_ADDRESSOF +# define BOOST_NO_CXX17_ITERATOR_TRAITS #endif // C++0x features in GCC 4.7.0 and later @@ -291,12 +294,10 @@ extern "C" char *gets (char *__s); #endif // -// C++17 features in GCC 6.1 and later +// C++17 features in GCC 7.1 and later // -#if (BOOST_LIBSTDCXX_VERSION < 60100) || (__cplusplus <= 201402L) -# define BOOST_NO_CXX17_STD_INVOKE -#endif #if (BOOST_LIBSTDCXX_VERSION < 70100) || (__cplusplus <= 201402L) +# define BOOST_NO_CXX17_STD_INVOKE # define BOOST_NO_CXX17_STD_APPLY #endif diff --git a/3rdparty/boost/boost/config/stdlib/modena.hpp b/3rdparty/boost/boost/config/stdlib/modena.hpp index 98bdc3fb3e..81919e0180 100644 --- a/3rdparty/boost/boost/config/stdlib/modena.hpp +++ b/3rdparty/boost/boost/config/stdlib/modena.hpp @@ -68,6 +68,7 @@ // C++17 features # define BOOST_NO_CXX17_STD_APPLY # define BOOST_NO_CXX17_STD_INVOKE +# define BOOST_NO_CXX17_ITERATOR_TRAITS #define BOOST_STDLIB "Modena C++ standard library" diff --git a/3rdparty/boost/boost/config/stdlib/msl.hpp b/3rdparty/boost/boost/config/stdlib/msl.hpp index 9606a9aeca..0e2e2afee8 100644 --- a/3rdparty/boost/boost/config/stdlib/msl.hpp +++ b/3rdparty/boost/boost/config/stdlib/msl.hpp @@ -92,5 +92,6 @@ // C++17 features # define BOOST_NO_CXX17_STD_APPLY # define BOOST_NO_CXX17_STD_INVOKE +# define BOOST_NO_CXX17_ITERATOR_TRAITS #define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__) diff --git a/3rdparty/boost/boost/config/stdlib/roguewave.hpp b/3rdparty/boost/boost/config/stdlib/roguewave.hpp index 380d0ff375..df6021551a 100644 --- a/3rdparty/boost/boost/config/stdlib/roguewave.hpp +++ b/3rdparty/boost/boost/config/stdlib/roguewave.hpp @@ -204,3 +204,4 @@ // C++17 features # define BOOST_NO_CXX17_STD_APPLY # define BOOST_NO_CXX17_STD_INVOKE +# define BOOST_NO_CXX17_ITERATOR_TRAITS diff --git a/3rdparty/boost/boost/config/stdlib/sgi.hpp b/3rdparty/boost/boost/config/stdlib/sgi.hpp index 5016ff627b..0c8ab2e4c1 100644 --- a/3rdparty/boost/boost/config/stdlib/sgi.hpp +++ b/3rdparty/boost/boost/config/stdlib/sgi.hpp @@ -162,5 +162,6 @@ // C++17 features # define BOOST_NO_CXX17_STD_APPLY # define BOOST_NO_CXX17_STD_INVOKE +# define BOOST_NO_CXX17_ITERATOR_TRAITS #define BOOST_STDLIB "SGI standard library" diff --git a/3rdparty/boost/boost/config/stdlib/stlport.hpp b/3rdparty/boost/boost/config/stdlib/stlport.hpp index 81e6ccf016..2e304e2b94 100644 --- a/3rdparty/boost/boost/config/stdlib/stlport.hpp +++ b/3rdparty/boost/boost/config/stdlib/stlport.hpp @@ -252,5 +252,6 @@ namespace boost { using std::min; using std::max; } // C++17 features # define BOOST_NO_CXX17_STD_APPLY # define BOOST_NO_CXX17_STD_INVOKE +# define BOOST_NO_CXX17_ITERATOR_TRAITS #define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT) diff --git a/3rdparty/boost/boost/config/stdlib/vacpp.hpp b/3rdparty/boost/boost/config/stdlib/vacpp.hpp index c159af259f..c4e1fb1847 100644 --- a/3rdparty/boost/boost/config/stdlib/vacpp.hpp +++ b/3rdparty/boost/boost/config/stdlib/vacpp.hpp @@ -68,5 +68,6 @@ // C++17 features # define BOOST_NO_CXX17_STD_APPLY # define BOOST_NO_CXX17_STD_INVOKE +# define BOOST_NO_CXX17_ITERATOR_TRAITS #define BOOST_STDLIB "Visual Age default standard library" diff --git a/3rdparty/boost/boost/config/stdlib/xlcpp_zos.hpp b/3rdparty/boost/boost/config/stdlib/xlcpp_zos.hpp index dce40f5090..4d5beb1855 100644 --- a/3rdparty/boost/boost/config/stdlib/xlcpp_zos.hpp +++ b/3rdparty/boost/boost/config/stdlib/xlcpp_zos.hpp @@ -57,3 +57,4 @@ #define BOOST_NO_CXX17_STD_INVOKE #define BOOST_NO_CXX17_STD_APPLY +#define BOOST_NO_CXX17_ITERATOR_TRAITS diff --git a/3rdparty/boost/boost/config/workaround.hpp b/3rdparty/boost/boost/config/workaround.hpp index 0ce8108c2e..fca8f3ab7e 100644 --- a/3rdparty/boost/boost/config/workaround.hpp +++ b/3rdparty/boost/boost/config/workaround.hpp @@ -87,8 +87,10 @@ #endif #ifndef BOOST_GCC #define BOOST_GCC_WORKAROUND_GUARD 1 +#define BOOST_GCC_VERSION_WORKAROUND_GUARD 1 #else #define BOOST_GCC_WORKAROUND_GUARD 0 +#define BOOST_GCC_VERSION_WORKAROUND_GUARD 0 #endif #ifndef BOOST_XLCPP_ZOS #define BOOST_XLCPP_ZOS_WORKAROUND_GUARD 1 diff --git a/3rdparty/boost/boost/container/container_fwd.hpp b/3rdparty/boost/boost/container/container_fwd.hpp index e85a6ce952..e4fe6f85c3 100644 --- a/3rdparty/boost/boost/container/container_fwd.hpp +++ b/3rdparty/boost/boost/container/container_fwd.hpp @@ -67,7 +67,7 @@ namespace detail{ //Create namespace to avoid compilation errors }}} -namespace boost{ namespace container{ namespace container_detail{ +namespace boost{ namespace container{ namespace dtl{ namespace bi = boost::intrusive; namespace bid = boost::intrusive::detail; }}} @@ -88,23 +88,14 @@ namespace boost{ namespace container{ namespace pmr{ namespace boost { namespace container { -//! Enumeration used to configure ordered associative containers -//! with a concrete tree implementation. -enum tree_type_enum -{ - red_black_tree, - avl_tree, - scapegoat_tree, - splay_tree -}; - #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED template class new_allocator; template > + ,class Allocator = new_allocator + ,class Options = void> class vector; template > class slist; -template -struct tree_opt; - -typedef tree_opt tree_assoc_defaults; - template ,class Allocator = new_allocator - ,class Options = tree_assoc_defaults > + ,class Options = void> class set; template ,class Allocator = new_allocator - ,class Options = tree_assoc_defaults > + ,class Options = void > class multiset; template ,class Allocator = new_allocator > - ,class Options = tree_assoc_defaults > + ,class Options = void > class map; template ,class Allocator = new_allocator > - ,class Options = tree_assoc_defaults > + ,class Options = void > class multimap; template -//! - optimize_size -typedef implementation_defined tree_assoc_defaults; - #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED //! Type used to tag that the input range is diff --git a/3rdparty/boost/boost/functional/hash/detail/float_functions.hpp b/3rdparty/boost/boost/container_hash/detail/float_functions.hpp similarity index 100% rename from 3rdparty/boost/boost/functional/hash/detail/float_functions.hpp rename to 3rdparty/boost/boost/container_hash/detail/float_functions.hpp diff --git a/3rdparty/boost/boost/functional/hash/detail/hash_float.hpp b/3rdparty/boost/boost/container_hash/detail/hash_float.hpp similarity index 97% rename from 3rdparty/boost/boost/functional/hash/detail/hash_float.hpp rename to 3rdparty/boost/boost/container_hash/detail/hash_float.hpp index 9fb8168459..f763428508 100644 --- a/3rdparty/boost/boost/functional/hash/detail/hash_float.hpp +++ b/3rdparty/boost/boost/container_hash/detail/hash_float.hpp @@ -11,9 +11,9 @@ #pragma once #endif -#include -#include -#include +#include +#include +#include #include #include #include @@ -241,7 +241,7 @@ namespace boost template inline bool is_zero(T v) { -#if !defined(__GNUC__) +#if !defined(__GNUC__) && !defined(__clang__) return v == 0; #else // GCC's '-Wfloat-equal' will complain about comparing diff --git a/3rdparty/boost/boost/functional/hash/detail/limits.hpp b/3rdparty/boost/boost/container_hash/detail/limits.hpp similarity index 100% rename from 3rdparty/boost/boost/functional/hash/detail/limits.hpp rename to 3rdparty/boost/boost/container_hash/detail/limits.hpp diff --git a/3rdparty/boost/boost/functional/hash/extensions.hpp b/3rdparty/boost/boost/container_hash/extensions.hpp similarity index 70% rename from 3rdparty/boost/boost/functional/hash/extensions.hpp rename to 3rdparty/boost/boost/container_hash/extensions.hpp index cb3c85623b..4eebb4bc93 100644 --- a/3rdparty/boost/boost/functional/hash/extensions.hpp +++ b/3rdparty/boost/boost/container_hash/extensions.hpp @@ -5,7 +5,7 @@ // Based on Peter Dimov's proposal // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf -// issue 6.18. +// issue 6.18. // This implements the extensions to the standard. // It's undocumented, so you shouldn't use it.... @@ -18,12 +18,11 @@ #pragma once #endif -#include +#include #include -#include +#include #include -#include -#include +#include #if !defined(BOOST_NO_CXX11_HDR_ARRAY) # include @@ -72,6 +71,56 @@ namespace boost 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) { @@ -171,19 +220,66 @@ namespace boost return boost::hash_detail::hash_tuple(v); } -# define BOOST_HASH_TUPLE_F(z, n, _) \ - template< \ - BOOST_PP_ENUM_PARAMS_Z(z, n, typename A) \ - > \ - inline std::size_t hash_value(std::tuple< \ - BOOST_PP_ENUM_PARAMS_Z(z, n, A) \ - > 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); } - BOOST_PP_REPEAT_FROM_TO(1, 11, BOOST_HASH_TUPLE_F, _) -# undef BOOST_HASH_TUPLE_F #endif #endif diff --git a/3rdparty/boost/boost/functional/hash/hash.hpp b/3rdparty/boost/boost/container_hash/hash.hpp similarity index 79% rename from 3rdparty/boost/boost/functional/hash/hash.hpp rename to 3rdparty/boost/boost/container_hash/hash.hpp index b461f5f0d7..76de7939eb 100644 --- a/3rdparty/boost/boost/functional/hash/hash.hpp +++ b/3rdparty/boost/boost/container_hash/hash.hpp @@ -5,7 +5,7 @@ // Based on Peter Dimov's proposal // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf -// issue 6.18. +// issue 6.18. // // This also contains public domain code from MurmurHash. From the // MurmurHash header: @@ -16,14 +16,14 @@ #if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP) #define BOOST_FUNCTIONAL_HASH_HASH_HPP -#include +#include #include -#include +#include #include #include #include #include -#include +#include #include #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) @@ -34,6 +34,10 @@ #include #endif +#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) +#include +#endif + #if defined(BOOST_MSVC) #pragma warning(push) @@ -58,6 +62,58 @@ # 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 +#endif + namespace boost { namespace hash_detail @@ -176,13 +232,35 @@ namespace boost 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&); +#endif + template typename boost::hash_detail::float_numbers::type hash_value(T); +#if BOOST_HASH_HAS_OPTIONAL + template + std::size_t hash_value(std::optional const&); +#endif + +#if BOOST_HASH_HAS_VARIANT + std::size_t hash_value(std::monostate); + template + std::size_t hash_value(std::variant const&); +#endif + #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX) std::size_t hash_value(std::type_index); #endif +#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 @@ -410,12 +488,49 @@ namespace boost 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); + } + } +#endif + +#if BOOST_HASH_HAS_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) { @@ -423,14 +538,30 @@ namespace boost } #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()); + return seed; + } + + inline std::size_t hash_value(std::error_condition const& v) { + std::size_t seed = 0; + hash_combine(seed, v.value()); + hash_combine(seed, &v.category()); + 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. // @@ -459,6 +590,16 @@ namespace boost } \ }; +#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) @@ -494,6 +635,19 @@ namespace boost 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) @@ -504,12 +658,24 @@ namespace boost 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. @@ -591,5 +757,5 @@ namespace boost #if !defined(BOOST_HASH_NO_EXTENSIONS) \ && !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP) -#include +#include #endif diff --git a/3rdparty/boost/boost/functional/hash/hash_fwd.hpp b/3rdparty/boost/boost/container_hash/hash_fwd.hpp similarity index 93% rename from 3rdparty/boost/boost/functional/hash/hash_fwd.hpp rename to 3rdparty/boost/boost/container_hash/hash_fwd.hpp index 01fe012ed6..a87c182d39 100644 --- a/3rdparty/boost/boost/functional/hash/hash_fwd.hpp +++ b/3rdparty/boost/boost/container_hash/hash_fwd.hpp @@ -10,13 +10,13 @@ #if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP) #define BOOST_FUNCTIONAL_HASH_FWD_HPP -#include +#include +#include + #if defined(BOOST_HAS_PRAGMA_ONCE) #pragma once #endif -#include -#include namespace boost { diff --git a/3rdparty/boost/boost/core/addressof.hpp b/3rdparty/boost/boost/core/addressof.hpp index 8ddda8be4a..f7eab06ba7 100644 --- a/3rdparty/boost/boost/core/addressof.hpp +++ b/3rdparty/boost/boost/core/addressof.hpp @@ -49,20 +49,20 @@ namespace boost { namespace detail { template -class addressof_ref { +class addrof_ref { public: - BOOST_FORCEINLINE addressof_ref(T& o) BOOST_NOEXCEPT + BOOST_FORCEINLINE addrof_ref(T& o) BOOST_NOEXCEPT : o_(o) { } BOOST_FORCEINLINE operator T&() const BOOST_NOEXCEPT { return o_; } private: - addressof_ref& operator=(const addressof_ref&); + addrof_ref& operator=(const addrof_ref&); T& o_; }; template -struct address_of { +struct addrof { static BOOST_FORCEINLINE T* get(T& o, long) BOOST_NOEXCEPT { return reinterpret_cast(& const_cast(reinterpret_cast(o))); @@ -76,38 +76,38 @@ struct address_of { #if !defined(BOOST_NO_CXX11_DECLTYPE) && \ (defined(__INTEL_COMPILER) || \ (defined(__clang__) && !defined(_LIBCPP_VERSION))) -typedef decltype(nullptr) addressof_null_t; +typedef decltype(nullptr) addrof_null_t; #else -typedef std::nullptr_t addressof_null_t; +typedef std::nullptr_t addrof_null_t; #endif template<> -struct address_of { - typedef addressof_null_t type; +struct addrof { + typedef addrof_null_t type; static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT { return &o; } }; template<> -struct address_of { - typedef const addressof_null_t type; +struct addrof { + typedef const addrof_null_t type; static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT { return &o; } }; template<> -struct address_of { - typedef volatile addressof_null_t type; +struct addrof { + typedef volatile addrof_null_t type; static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT { return &o; } }; template<> -struct address_of { - typedef const volatile addressof_null_t type; +struct addrof { + typedef const volatile addrof_null_t type; static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT { return &o; } @@ -127,9 +127,9 @@ addressof(T& o) BOOST_NOEXCEPT { #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) || \ BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120) - return detail::address_of::get(o, 0); + return boost::detail::addrof::get(o, 0); #else - return detail::address_of::get(detail::addressof_ref(o), 0); + return boost::detail::addrof::get(boost::detail::addrof_ref(o), 0); #endif } @@ -137,14 +137,14 @@ addressof(T& o) BOOST_NOEXCEPT namespace detail { template -struct addressof_result { +struct addrof_result { typedef T* type; }; } /* detail */ template -BOOST_FORCEINLINE typename detail::addressof_result::type +BOOST_FORCEINLINE typename boost::detail::addrof_result::type addressof(T (&o)[N]) BOOST_NOEXCEPT { return &o; @@ -170,79 +170,79 @@ const T (*addressof(const T (&o)[N]) BOOST_NOEXCEPT)[N] namespace detail { template -T addressof_declval() BOOST_NOEXCEPT; +T addrof_declval() BOOST_NOEXCEPT; template -struct addressof_void { +struct addrof_void { typedef void type; }; template -struct addressof_member_operator { +struct addrof_member_operator { static constexpr bool value = false; }; template -struct addressof_member_operator().operator&())>::type> { +struct addrof_member_operator().operator&())>::type> { static constexpr bool value = true; }; #if BOOST_WORKAROUND(BOOST_INTEL, < 1600) -struct addressof_addressable { }; +struct addrof_addressable { }; -addressof_addressable* -operator&(addressof_addressable&) BOOST_NOEXCEPT; +addrof_addressable* +operator&(addrof_addressable&) BOOST_NOEXCEPT; #endif template -struct addressof_non_member_operator { +struct addrof_non_member_operator { static constexpr bool value = false; }; template -struct addressof_non_member_operator()))>::type> { +struct addrof_non_member_operator()))>::type> { static constexpr bool value = true; }; template -struct addressof_expression { +struct addrof_expression { static constexpr bool value = false; }; template -struct addressof_expression())>::type> { +struct addrof_expression())>::type> { static constexpr bool value = true; }; template -struct addressof_is_constexpr { - static constexpr bool value = addressof_expression::value && - !addressof_member_operator::value && - !addressof_non_member_operator::value; +struct addrof_is_constexpr { + static constexpr bool value = addrof_expression::value && + !addrof_member_operator::value && + !addrof_non_member_operator::value; }; template -struct addressof_if { }; +struct addrof_if { }; template -struct addressof_if { +struct addrof_if { typedef T* type; }; template BOOST_FORCEINLINE -typename addressof_if::value, T>::type +typename addrof_if::value, T>::type addressof(T& o) BOOST_NOEXCEPT { - return address_of::get(addressof_ref(o), 0); + return addrof::get(addrof_ref(o), 0); } template constexpr BOOST_FORCEINLINE -typename addressof_if::value, T>::type +typename addrof_if::value, T>::type addressof(T& o) BOOST_NOEXCEPT { return &o; @@ -254,7 +254,7 @@ template constexpr BOOST_FORCEINLINE T* addressof(T& o) BOOST_NOEXCEPT { - return detail::addressof(o); + return boost::detail::addressof(o); } #endif diff --git a/3rdparty/boost/boost/cstdint.hpp b/3rdparty/boost/boost/cstdint.hpp index 31b67417ae..c8474c4623 100644 --- a/3rdparty/boost/boost/cstdint.hpp +++ b/3rdparty/boost/boost/cstdint.hpp @@ -34,6 +34,17 @@ #endif #include +// +// For the following code we get several warnings along the lines of: +// +// boost/cstdint.hpp:428:35: error: use of C99 long long integer constant +// +// So we declare this a system header to suppress these warnings. +// See also https://github.com/boostorg/config/issues/190 +// +#if defined(__GNUC__) && (__GNUC__ >= 4) +#pragma GCC system_header +#endif // // Note that GLIBC is a bit inconsistent about whether int64_t is defined or not @@ -60,7 +71,7 @@ # include // There is a bug in Cygwin two _C macros -# if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__) +# if defined(INTMAX_C) && defined(__CYGWIN__) # undef INTMAX_C # undef UINTMAX_C # define INTMAX_C(c) c##LL @@ -367,12 +378,9 @@ namespace boost #include #endif -// PGI seems to not support intptr_t/uintptr_t properly. BOOST_HAS_STDINT_H is not defined for this compiler by Boost.Config. -#if !defined(__PGIC__) - #if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \ || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \ - || defined(__CYGWIN__) \ + || defined(__CYGWIN__) || defined(__VXWORKS__) \ || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \ || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || (defined(sun) && !defined(BOOST_HAS_STDINT_H)) || defined(INTPTR_MAX) @@ -393,8 +401,6 @@ namespace boost { #endif -#endif // !defined(__PGIC__) - #endif // BOOST_CSTDINT_HPP @@ -413,16 +419,6 @@ INT#_C macros if they're not already defined (John Maddock). #if !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && \ (!defined(INT8_C) || !defined(INT16_C) || !defined(INT32_C) || !defined(INT64_C)) // -// For the following code we get several warnings along the lines of: -// -// boost/cstdint.hpp:428:35: error: use of C99 long long integer constant -// -// So we declare this a system header to suppress these warnings. -// -#if defined(__GNUC__) && (__GNUC__ >= 4) -#pragma GCC system_header -#endif -// // Undef the macros as a precaution, since we may get here if has failed // to define them all, see https://svn.boost.org/trac/boost/ticket/12786 // diff --git a/3rdparty/boost/boost/detail/basic_pointerbuf.hpp b/3rdparty/boost/boost/detail/basic_pointerbuf.hpp index 1d8cf373b3..85618f92ab 100644 --- a/3rdparty/boost/boost/detail/basic_pointerbuf.hpp +++ b/3rdparty/boost/boost/detail/basic_pointerbuf.hpp @@ -39,7 +39,7 @@ protected: typedef typename base_type::off_type off_type; public: - basic_pointerbuf() : base_type() { setbuf(0, 0); } + basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); } const charT* getnext() { return this->gptr(); } #ifndef BOOST_NO_USING_TEMPLATE diff --git a/3rdparty/boost/boost/function.hpp b/3rdparty/boost/boost/function.hpp index b72842bb3b..68a25ab069 100644 --- a/3rdparty/boost/boost/function.hpp +++ b/3rdparty/boost/boost/function.hpp @@ -10,15 +10,21 @@ // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the // design of this library. +#ifndef BOOST_FUNCTION_MAX_ARGS +# define BOOST_FUNCTION_MAX_ARGS 10 +#endif // BOOST_FUNCTION_MAX_ARGS + +#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS) + +#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) +#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0 +#endif + #include // unary_function, binary_function #include #include -#ifndef BOOST_FUNCTION_MAX_ARGS -# define BOOST_FUNCTION_MAX_ARGS 10 -#endif // BOOST_FUNCTION_MAX_ARGS - // Include the prologue here so that the use of file-level iteration // in anything that may be included by function_template.hpp doesn't break #include @@ -64,3 +70,5 @@ # include BOOST_PP_ITERATE() # undef BOOST_PP_ITERATION_PARAMS_1 #endif + +#endif // !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS) diff --git a/3rdparty/boost/boost/function/detail/gen_maybe_include.pl b/3rdparty/boost/boost/function/detail/gen_maybe_include.pl index d0629205e1..bc409840b6 100644 --- a/3rdparty/boost/boost/function/detail/gen_maybe_include.pl +++ b/3rdparty/boost/boost/function/detail/gen_maybe_include.pl @@ -27,6 +27,8 @@ for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) { print OUT "#elif"; } print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n"; + print OUT "# undef BOOST_FUNCTION_MAX_ARGS_DEFINED\n"; + print OUT "# define BOOST_FUNCTION_MAX_ARGS_DEFINED $on_arg\n"; print OUT "# ifndef BOOST_FUNCTION_$on_arg\n"; print OUT "# define BOOST_FUNCTION_$on_arg\n"; print OUT "# include \n"; diff --git a/3rdparty/boost/boost/function/detail/maybe_include.hpp b/3rdparty/boost/boost/function/detail/maybe_include.hpp index 92f71bb227..ec88905dcd 100644 --- a/3rdparty/boost/boost/function/detail/maybe_include.hpp +++ b/3rdparty/boost/boost/function/detail/maybe_include.hpp @@ -8,256 +8,358 @@ // For more information, see http://www.boost.org #if BOOST_FUNCTION_NUM_ARGS == 0 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 0 # ifndef BOOST_FUNCTION_0 # define BOOST_FUNCTION_0 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 1 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 1 # ifndef BOOST_FUNCTION_1 # define BOOST_FUNCTION_1 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 2 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 2 # ifndef BOOST_FUNCTION_2 # define BOOST_FUNCTION_2 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 3 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 3 # ifndef BOOST_FUNCTION_3 # define BOOST_FUNCTION_3 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 4 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 4 # ifndef BOOST_FUNCTION_4 # define BOOST_FUNCTION_4 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 5 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 5 # ifndef BOOST_FUNCTION_5 # define BOOST_FUNCTION_5 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 6 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 6 # ifndef BOOST_FUNCTION_6 # define BOOST_FUNCTION_6 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 7 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 7 # ifndef BOOST_FUNCTION_7 # define BOOST_FUNCTION_7 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 8 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 8 # ifndef BOOST_FUNCTION_8 # define BOOST_FUNCTION_8 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 9 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 9 # ifndef BOOST_FUNCTION_9 # define BOOST_FUNCTION_9 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 10 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 10 # ifndef BOOST_FUNCTION_10 # define BOOST_FUNCTION_10 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 11 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 11 # ifndef BOOST_FUNCTION_11 # define BOOST_FUNCTION_11 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 12 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 12 # ifndef BOOST_FUNCTION_12 # define BOOST_FUNCTION_12 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 13 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 13 # ifndef BOOST_FUNCTION_13 # define BOOST_FUNCTION_13 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 14 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 14 # ifndef BOOST_FUNCTION_14 # define BOOST_FUNCTION_14 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 15 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 15 # ifndef BOOST_FUNCTION_15 # define BOOST_FUNCTION_15 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 16 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 16 # ifndef BOOST_FUNCTION_16 # define BOOST_FUNCTION_16 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 17 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 17 # ifndef BOOST_FUNCTION_17 # define BOOST_FUNCTION_17 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 18 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 18 # ifndef BOOST_FUNCTION_18 # define BOOST_FUNCTION_18 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 19 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 19 # ifndef BOOST_FUNCTION_19 # define BOOST_FUNCTION_19 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 20 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 20 # ifndef BOOST_FUNCTION_20 # define BOOST_FUNCTION_20 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 21 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 21 # ifndef BOOST_FUNCTION_21 # define BOOST_FUNCTION_21 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 22 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 22 # ifndef BOOST_FUNCTION_22 # define BOOST_FUNCTION_22 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 23 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 23 # ifndef BOOST_FUNCTION_23 # define BOOST_FUNCTION_23 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 24 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 24 # ifndef BOOST_FUNCTION_24 # define BOOST_FUNCTION_24 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 25 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 25 # ifndef BOOST_FUNCTION_25 # define BOOST_FUNCTION_25 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 26 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 26 # ifndef BOOST_FUNCTION_26 # define BOOST_FUNCTION_26 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 27 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 27 # ifndef BOOST_FUNCTION_27 # define BOOST_FUNCTION_27 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 28 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 28 # ifndef BOOST_FUNCTION_28 # define BOOST_FUNCTION_28 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 29 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 29 # ifndef BOOST_FUNCTION_29 # define BOOST_FUNCTION_29 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 30 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 30 # ifndef BOOST_FUNCTION_30 # define BOOST_FUNCTION_30 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 31 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 31 # ifndef BOOST_FUNCTION_31 # define BOOST_FUNCTION_31 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 32 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 32 # ifndef BOOST_FUNCTION_32 # define BOOST_FUNCTION_32 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 33 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 33 # ifndef BOOST_FUNCTION_33 # define BOOST_FUNCTION_33 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 34 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 34 # ifndef BOOST_FUNCTION_34 # define BOOST_FUNCTION_34 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 35 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 35 # ifndef BOOST_FUNCTION_35 # define BOOST_FUNCTION_35 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 36 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 36 # ifndef BOOST_FUNCTION_36 # define BOOST_FUNCTION_36 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 37 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 37 # ifndef BOOST_FUNCTION_37 # define BOOST_FUNCTION_37 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 38 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 38 # ifndef BOOST_FUNCTION_38 # define BOOST_FUNCTION_38 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 39 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 39 # ifndef BOOST_FUNCTION_39 # define BOOST_FUNCTION_39 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 40 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 40 # ifndef BOOST_FUNCTION_40 # define BOOST_FUNCTION_40 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 41 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 41 # ifndef BOOST_FUNCTION_41 # define BOOST_FUNCTION_41 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 42 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 42 # ifndef BOOST_FUNCTION_42 # define BOOST_FUNCTION_42 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 43 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 43 # ifndef BOOST_FUNCTION_43 # define BOOST_FUNCTION_43 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 44 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 44 # ifndef BOOST_FUNCTION_44 # define BOOST_FUNCTION_44 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 45 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 45 # ifndef BOOST_FUNCTION_45 # define BOOST_FUNCTION_45 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 46 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 46 # ifndef BOOST_FUNCTION_46 # define BOOST_FUNCTION_46 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 47 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 47 # ifndef BOOST_FUNCTION_47 # define BOOST_FUNCTION_47 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 48 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 48 # ifndef BOOST_FUNCTION_48 # define BOOST_FUNCTION_48 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 49 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 49 # ifndef BOOST_FUNCTION_49 # define BOOST_FUNCTION_49 # include # endif #elif BOOST_FUNCTION_NUM_ARGS == 50 +# undef BOOST_FUNCTION_MAX_ARGS_DEFINED +# define BOOST_FUNCTION_MAX_ARGS_DEFINED 50 # ifndef BOOST_FUNCTION_50 # define BOOST_FUNCTION_50 # include diff --git a/3rdparty/boost/boost/function/function_base.hpp b/3rdparty/boost/boost/function/function_base.hpp index 21a0c0da7f..841affb49a 100644 --- a/3rdparty/boost/boost/function/function_base.hpp +++ b/3rdparty/boost/boost/function/function_base.hpp @@ -438,9 +438,14 @@ namespace boost { functor_manager_operation_type op, mpl::false_) { typedef functor_wrapper functor_wrapper_type; +#if defined(BOOST_NO_CXX11_ALLOCATOR) typedef typename Allocator::template rebind::other wrapper_allocator_type; typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type; +#else + using wrapper_allocator_type = typename std::allocator_traits::template rebind_alloc; + using wrapper_allocator_pointer_type = typename std::allocator_traits::pointer; +#endif if (op == clone_functor_tag) { // Clone the functor @@ -450,7 +455,11 @@ namespace boost { static_cast(in_buffer.members.obj_ptr); wrapper_allocator_type wrapper_allocator(static_cast(*f)); wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); +#if defined(BOOST_NO_CXX11_ALLOCATOR) wrapper_allocator.construct(copy, *f); +#else + std::allocator_traits::construct(wrapper_allocator, copy, *f); +#endif // Get back to the original pointer type functor_wrapper_type* new_f = static_cast(copy); @@ -463,7 +472,11 @@ namespace boost { functor_wrapper_type* victim = static_cast(in_buffer.members.obj_ptr); wrapper_allocator_type wrapper_allocator(static_cast(*victim)); +#if defined(BOOST_NO_CXX11_ALLOCATOR) wrapper_allocator.destroy(victim); +#else + std::allocator_traits::destroy(wrapper_allocator, victim); +#endif wrapper_allocator.deallocate(victim,1); out_buffer.members.obj_ptr = 0; } else if (op == check_functor_type_tag) { @@ -689,6 +702,10 @@ public: // should be protected, but GCC 2.95.3 will fail to allow access mutable detail::function::function_buffer functor; }; +#if defined(BOOST_CLANG) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wweak-vtables" +#endif /** * The bad_function_call exception class is thrown when a boost::function * object is invoked @@ -698,6 +715,9 @@ class bad_function_call : public std::runtime_error public: bad_function_call() : std::runtime_error("call to empty boost::function") {} }; +#if defined(BOOST_CLANG) +# pragma clang diagnostic pop +#endif #ifndef BOOST_NO_SFINAE inline bool operator==(const function_base& f, diff --git a/3rdparty/boost/boost/function/function_template.hpp b/3rdparty/boost/boost/function/function_template.hpp index 7984c8323f..177b60a7b4 100644 --- a/3rdparty/boost/boost/function/function_template.hpp +++ b/3rdparty/boost/boost/function/function_template.hpp @@ -590,12 +590,21 @@ namespace boost { assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const { typedef functor_wrapper functor_wrapper_type; +#if defined(BOOST_NO_CXX11_ALLOCATOR) typedef typename Allocator::template rebind::other wrapper_allocator_type; typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type; +#else + using wrapper_allocator_type = typename std::allocator_traits::template rebind_alloc; + using wrapper_allocator_pointer_type = typename std::allocator_traits::pointer; +#endif wrapper_allocator_type wrapper_allocator(a); wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); +#if defined(BOOST_NO_CXX11_ALLOCATOR) wrapper_allocator.construct(copy, functor_wrapper_type(f,a)); +#else + std::allocator_traits::construct(wrapper_allocator, copy, functor_wrapper_type(f,a)); +#endif functor_wrapper_type* new_f = static_cast(copy); functor.members.obj_ptr = new_f; } @@ -895,7 +904,9 @@ namespace boost { if (!f.empty()) { this->vtable = f.vtable; if (this->has_trivial_copy_and_destroy()) - this->functor = f.functor; + // Don't operate on storage directly since union type doesn't relax + // strict aliasing rules, despite of having member char type. + std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer)); else get_vtable()->base.manager(f.functor, this->functor, boost::detail::function::clone_functor_tag); @@ -983,7 +994,9 @@ namespace boost { if (!f.empty()) { this->vtable = f.vtable; if (this->has_trivial_copy_and_destroy()) - this->functor = f.functor; + // Don't operate on storage directly since union type doesn't relax + // strict aliasing rules, despite of having member char type. + std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data)); else get_vtable()->base.manager(f.functor, this->functor, boost::detail::function::move_functor_tag); diff --git a/3rdparty/boost/boost/function_output_iterator.hpp b/3rdparty/boost/boost/function_output_iterator.hpp index dd8c44d394..15dbcb9f54 100644 --- a/3rdparty/boost/boost/function_output_iterator.hpp +++ b/3rdparty/boost/boost/function_output_iterator.hpp @@ -1,62 +1,14 @@ -// (C) Copyright Jeremy Siek 2001. +// (C) Copyright Andrey Semashev 2017. // 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) -// Revision History: - -// 27 Feb 2001 Jeremy Siek -// Initial checkin. - #ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP #define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP -#include - -namespace boost { -namespace iterators { - - template - class function_output_iterator { - typedef function_output_iterator self; - public: - typedef std::output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - explicit function_output_iterator() {} - - explicit function_output_iterator(const UnaryFunction& f) - : m_f(f) {} - - struct output_proxy { - output_proxy(UnaryFunction& f) : m_f(f) { } - template output_proxy& operator=(const T& value) { - m_f(value); - return *this; - } - UnaryFunction& m_f; - }; - output_proxy operator*() { return output_proxy(m_f); } - self& operator++() { return *this; } - self& operator++(int) { return *this; } - private: - UnaryFunction m_f; - }; - - template - inline function_output_iterator - make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) { - return function_output_iterator(f); - } - -} // namespace iterators - -using iterators::function_output_iterator; -using iterators::make_function_output_iterator; +// This is a deprecated header left for backward compatibility. +// Use boost/iterator/function_output_iterator.hpp instead. -} // namespace boost +#include #endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP diff --git a/3rdparty/boost/boost/functional/hash.hpp b/3rdparty/boost/boost/functional/hash.hpp index 44983f19b2..327a3ecae7 100644 --- a/3rdparty/boost/boost/functional/hash.hpp +++ b/3rdparty/boost/boost/functional/hash.hpp @@ -3,5 +3,4 @@ // 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 diff --git a/3rdparty/boost/boost/functional/hash_fwd.hpp b/3rdparty/boost/boost/functional/hash_fwd.hpp index eea9073884..62bc23c73b 100644 --- a/3rdparty/boost/boost/functional/hash_fwd.hpp +++ b/3rdparty/boost/boost/functional/hash_fwd.hpp @@ -3,9 +3,4 @@ // 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 -#if defined(BOOST_HAS_PRAGMA_ONCE) -#pragma once -#endif - -#include +#include diff --git a/3rdparty/boost/boost/iterator.hpp b/3rdparty/boost/boost/iterator.hpp deleted file mode 100644 index c9c6197950..0000000000 --- a/3rdparty/boost/boost/iterator.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// (C) Copyright Beman Dawes 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) - -#ifndef BOOST_ITERATOR_HPP -#define BOOST_ITERATOR_HPP - -// This header is obsolete and will be deprecated. - -#include -#include // std::ptrdiff_t - -namespace boost -{ - -using std::iterator; - -} // namespace boost - -#endif // BOOST_ITERATOR_HPP diff --git a/3rdparty/boost/boost/iterator/distance.hpp b/3rdparty/boost/boost/iterator/distance.hpp new file mode 100644 index 0000000000..8cf3f15c44 --- /dev/null +++ b/3rdparty/boost/boost/iterator/distance.hpp @@ -0,0 +1,65 @@ +// Copyright (C) 2017 Michel Morin. +// +// 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_ITERATOR_DISTANCE_HPP +#define BOOST_ITERATOR_DISTANCE_HPP + +#include +#include +#include + +namespace boost { +namespace iterators { + + namespace detail { + template + inline BOOST_CXX14_CONSTEXPR typename iterator_difference::type + distance_impl( + SinglePassIterator first + , SinglePassIterator last + , single_pass_traversal_tag + ) + { + typename iterator_difference::type n = 0; + while (first != last) { + ++first; + ++n; + } + return n; + } + + template + inline BOOST_CXX14_CONSTEXPR typename iterator_difference::type + distance_impl( + RandomAccessIterator first + , RandomAccessIterator last + , random_access_traversal_tag + ) + { + return last - first; + } + } + + namespace distance_adl_barrier { + template + inline BOOST_CXX14_CONSTEXPR typename iterator_difference::type + distance(SinglePassIterator first, SinglePassIterator last) + { + return detail::distance_impl( + first, last, typename iterator_traversal::type() + ); + } + } + + using namespace distance_adl_barrier; + +} // namespace iterators + +using iterators::distance; + +} // namespace boost + +#endif diff --git a/3rdparty/boost/boost/iterator/function_output_iterator.hpp b/3rdparty/boost/boost/iterator/function_output_iterator.hpp new file mode 100644 index 0000000000..51fe835089 --- /dev/null +++ b/3rdparty/boost/boost/iterator/function_output_iterator.hpp @@ -0,0 +1,62 @@ +// (C) Copyright Jeremy Siek 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) + +// Revision History: + +// 27 Feb 2001 Jeremy Siek +// Initial checkin. + +#ifndef BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP +#define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP + +#include + +namespace boost { +namespace iterators { + + template + class function_output_iterator { + typedef function_output_iterator self; + public: + typedef std::output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + explicit function_output_iterator() {} + + explicit function_output_iterator(const UnaryFunction& f) + : m_f(f) {} + + struct output_proxy { + output_proxy(UnaryFunction& f) : m_f(f) { } + template output_proxy& operator=(const T& value) { + m_f(value); + return *this; + } + UnaryFunction& m_f; + }; + output_proxy operator*() { return output_proxy(m_f); } + self& operator++() { return *this; } + self& operator++(int) { return *this; } + private: + UnaryFunction m_f; + }; + + template + inline function_output_iterator + make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) { + return function_output_iterator(f); + } + +} // namespace iterators + +using iterators::function_output_iterator; +using iterators::make_function_output_iterator; + +} // namespace boost + +#endif // BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP diff --git a/3rdparty/boost/boost/iterator/iterator_adaptor.hpp b/3rdparty/boost/boost/iterator/iterator_adaptor.hpp index 87cfd0583f..f803fc65ed 100644 --- a/3rdparty/boost/boost/iterator/iterator_adaptor.hpp +++ b/3rdparty/boost/boost/iterator/iterator_adaptor.hpp @@ -8,8 +8,6 @@ #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP #include -#include -#include #include #include diff --git a/3rdparty/boost/boost/iterator/iterator_categories.hpp b/3rdparty/boost/boost/iterator/iterator_categories.hpp index 71202c993a..baf805af6e 100644 --- a/3rdparty/boost/boost/iterator/iterator_categories.hpp +++ b/3rdparty/boost/boost/iterator/iterator_categories.hpp @@ -7,7 +7,6 @@ # define BOOST_ITERATOR_CATEGORIES_HPP # include -# include # include # include @@ -21,6 +20,8 @@ # include +#include + namespace boost { namespace iterators { @@ -116,7 +117,7 @@ struct iterator_category_to_traversal template struct iterator_traversal : iterator_category_to_traversal< - typename boost::detail::iterator_traits::iterator_category + typename std::iterator_traits::iterator_category > {}; diff --git a/3rdparty/boost/boost/iterator/iterator_concepts.hpp b/3rdparty/boost/boost/iterator/iterator_concepts.hpp index 1a9f7d6398..415cc496a0 100644 --- a/3rdparty/boost/boost/iterator/iterator_concepts.hpp +++ b/3rdparty/boost/boost/iterator/iterator_concepts.hpp @@ -9,9 +9,6 @@ #include #include -// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems. -#include - #include #include @@ -27,6 +24,7 @@ #include #include +#include #include @@ -44,8 +42,8 @@ namespace boost_concepts , boost::CopyConstructible { - typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type value_type; - typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::reference reference; + typedef BOOST_DEDUCED_TYPENAME std::iterator_traits::value_type value_type; + typedef BOOST_DEDUCED_TYPENAME std::iterator_traits::reference reference; BOOST_CONCEPT_USAGE(ReadableIterator) { @@ -59,7 +57,7 @@ namespace boost_concepts template < typename Iterator - , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type + , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits::value_type > struct WritableIterator : boost::CopyConstructible @@ -75,7 +73,7 @@ namespace boost_concepts template < typename Iterator - , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::value_type + , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits::value_type > struct WritableIteratorConcept : WritableIterator {}; @@ -92,7 +90,7 @@ namespace boost_concepts BOOST_concept(LvalueIterator,(Iterator)) { - typedef typename boost::detail::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::value_type value_type; BOOST_CONCEPT_USAGE(LvalueIterator) { @@ -144,7 +142,7 @@ namespace boost_concepts : SinglePassIterator , boost::DefaultConstructible { - typedef typename boost::detail::iterator_traits::difference_type difference_type; + typedef typename std::iterator_traits::difference_type difference_type; BOOST_MPL_ASSERT((boost::is_integral)); BOOST_MPL_ASSERT_RELATION(std::numeric_limits::is_signed, ==, true); @@ -221,7 +219,7 @@ namespace boost_concepts boost::random_access_traversal_tag, boost::random_access_traversal_tag) { bool b; - typename boost::detail::iterator_traits::difference_type n; + typename std::iterator_traits::difference_type n; b = i1 < i2; b = i1 <= i2; b = i1 > i2; diff --git a/3rdparty/boost/boost/iterator/iterator_facade.hpp b/3rdparty/boost/boost/iterator/iterator_facade.hpp index 7b11d0aec1..225c53a231 100644 --- a/3rdparty/boost/boost/iterator/iterator_facade.hpp +++ b/3rdparty/boost/boost/iterator/iterator_facade.hpp @@ -8,7 +8,6 @@ #define BOOST_ITERATOR_FACADE_23022003THW_HPP #include -#include #include #include #include @@ -37,6 +36,8 @@ #include #include +#include + #include // this goes last namespace boost { diff --git a/3rdparty/boost/boost/iterator/iterator_traits.hpp b/3rdparty/boost/boost/iterator/iterator_traits.hpp index 1a5f1e0d60..6582a68f50 100644 --- a/3rdparty/boost/boost/iterator/iterator_traits.hpp +++ b/3rdparty/boost/boost/iterator/iterator_traits.hpp @@ -5,9 +5,10 @@ #ifndef ITERATOR_TRAITS_DWA200347_HPP # define ITERATOR_TRAITS_DWA200347_HPP -# include # include +#include + namespace boost { namespace iterators { @@ -19,32 +20,32 @@ namespace iterators { template struct iterator_value { - typedef typename boost::detail::iterator_traits::value_type type; + typedef typename std::iterator_traits::value_type type; }; template struct iterator_reference { - typedef typename boost::detail::iterator_traits::reference type; + typedef typename std::iterator_traits::reference type; }; template struct iterator_pointer { - typedef typename boost::detail::iterator_traits::pointer type; + typedef typename std::iterator_traits::pointer type; }; template struct iterator_difference { - typedef typename boost::detail::iterator_traits::difference_type type; + typedef typename std::iterator_traits::difference_type type; }; template struct iterator_category { - typedef typename boost::detail::iterator_traits::iterator_category type; + typedef typename std::iterator_traits::iterator_category type; }; } // namespace iterators diff --git a/3rdparty/boost/boost/iterator/reverse_iterator.hpp b/3rdparty/boost/boost/iterator/reverse_iterator.hpp index 7ed6b1b5ef..03b7925ca7 100644 --- a/3rdparty/boost/boost/iterator/reverse_iterator.hpp +++ b/3rdparty/boost/boost/iterator/reverse_iterator.hpp @@ -7,7 +7,6 @@ #ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP #define BOOST_REVERSE_ITERATOR_23022003THW_HPP -#include #include namespace boost { diff --git a/3rdparty/boost/boost/lexical_cast/detail/converter_lexical_streams.hpp b/3rdparty/boost/boost/lexical_cast/detail/converter_lexical_streams.hpp index 7bee25e1ad..3758a9cc21 100644 --- a/3rdparty/boost/boost/lexical_cast/detail/converter_lexical_streams.hpp +++ b/3rdparty/boost/boost/lexical_cast/detail/converter_lexical_streams.hpp @@ -200,18 +200,18 @@ namespace boost { } #endif - bool shl_char_array(CharT const* str) BOOST_NOEXCEPT { - start = str; - finish = start + Traits::length(str); + bool shl_char_array(CharT const* str_value) BOOST_NOEXCEPT { + start = str_value; + finish = start + Traits::length(str_value); return true; } template - bool shl_char_array(T const* str) { + bool shl_char_array(T const* str_value) { BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)), "boost::lexical_cast does not support narrowing of char types." "Use boost::locale instead" ); - return shl_input_streamable(str); + return shl_input_streamable(str_value); } bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT { @@ -424,8 +424,8 @@ namespace boost { bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast(ch)); } bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast(ch)); } bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast(ch)); } - bool operator<<(char const* str) { return shl_char_array(str); } - bool operator<<(char* str) { return shl_char_array(str); } + bool operator<<(char const* str_value) { return shl_char_array(str_value); } + bool operator<<(char* str_value) { return shl_char_array(str_value); } bool operator<<(short n) { return shl_signed(n); } bool operator<<(int n) { return shl_signed(n); } bool operator<<(long n) { return shl_signed(n); } diff --git a/3rdparty/boost/boost/math/common_factor_ct.hpp b/3rdparty/boost/boost/math/common_factor_ct.hpp deleted file mode 100644 index 3ca0905945..0000000000 --- a/3rdparty/boost/boost/math/common_factor_ct.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// Boost common_factor_ct.hpp header file ----------------------------------// - -// (C) Copyright John Maddock 2017. -// 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 for updates, documentation, and revision history. - -#ifndef BOOST_MATH_COMMON_FACTOR_CT_HPP -#define BOOST_MATH_COMMON_FACTOR_CT_HPP - -#include - -namespace boost -{ -namespace math -{ - - using boost::integer::static_gcd; - using boost::integer::static_lcm; - using boost::integer::static_gcd_type; - -} // namespace math -} // namespace boost - - -#endif // BOOST_MATH_COMMON_FACTOR_CT_HPP diff --git a/3rdparty/boost/boost/math/special_functions/detail/fp_traits.hpp b/3rdparty/boost/boost/math/special_functions/detail/fp_traits.hpp index 09dc5169aa..c957022223 100644 --- a/3rdparty/boost/boost/math/special_functions/detail/fp_traits.hpp +++ b/3rdparty/boost/boost/math/special_functions/detail/fp_traits.hpp @@ -556,7 +556,8 @@ struct select_native && !defined(__FAST_MATH__)\ && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)\ && !defined(BOOST_INTEL)\ - && !defined(sun) + && !defined(sun)\ + && !defined(__VXWORKS__) # define BOOST_MATH_USE_STD_FPCLASSIFY #endif diff --git a/3rdparty/boost/boost/math/special_functions/math_fwd.hpp b/3rdparty/boost/boost/math/special_functions/math_fwd.hpp index 9becef9f6d..4f44f56113 100644 --- a/3rdparty/boost/boost/math/special_functions/math_fwd.hpp +++ b/3rdparty/boost/boost/math/special_functions/math_fwd.hpp @@ -263,6 +263,30 @@ namespace boost typename tools::promote_args::type hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1); + template + typename tools::promote_args::type chebyshev_next(T1 const & x, T2 const & Tn, T3 const & Tn_1); + + template + typename tools::promote_args::type + chebyshev_t(unsigned n, Real const & x, const Policy&); + template + typename tools::promote_args::type chebyshev_t(unsigned n, Real const & x); + + template + typename tools::promote_args::type + chebyshev_u(unsigned n, Real const & x, const Policy&); + template + typename tools::promote_args::type chebyshev_u(unsigned n, Real const & x); + + template + typename tools::promote_args::type + chebyshev_t_prime(unsigned n, Real const & x, const Policy&); + template + typename tools::promote_args::type chebyshev_t_prime(unsigned n, Real const & x); + + template + Real chebyshev_clenshaw_recurrence(const Real* const c, size_t length, const T2& x); + template std::complex::type> spherical_harmonic(unsigned n, int m, T1 theta, T2 phi); @@ -1033,7 +1057,7 @@ namespace boost typename tools::promote_args::type epsilon_difference(const T&, const U&); template - T unchecked_bernoulli_b2n(const std::size_t n); + BOOST_MATH_CONSTEXPR_TABLE_FUNCTION T unchecked_bernoulli_b2n(const std::size_t n); template T bernoulli_b2n(const int i, const Policy &pol); template @@ -1189,6 +1213,19 @@ namespace boost hermite(unsigned n, T x){ return ::boost::math::hermite(n, x, Policy()); }\ \ using boost::math::hermite_next;\ +\ + using boost::math::chebyshev_next;\ +\ + template\ + Real chebyshev_t(unsigned n, Real const & x){ return ::boost::math::chebyshev_t(n, x, Policy()); }\ +\ + template\ + Real chebyshev_u(unsigned n, Real const & x){ return ::boost::math::chebyshev_u(n, x, Policy()); }\ +\ + template\ + Real chebyshev_t_prime(unsigned n, Real const & x){ return ::boost::math::chebyshev_t_prime(n, x, Policy()); }\ +\ + using ::boost::math::chebyshev_clenshaw_recurrence;\ \ template \ inline std::complex::type> \ diff --git a/3rdparty/boost/boost/math/tools/config.hpp b/3rdparty/boost/boost/math/tools/config.hpp index 8131facb98..17bfec16fe 100644 --- a/3rdparty/boost/boost/math/tools/config.hpp +++ b/3rdparty/boost/boost/math/tools/config.hpp @@ -31,7 +31,7 @@ #if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \ || (defined(__hppa) && !defined(__OpenBSD__)) || (defined(__NO_LONG_DOUBLE_MATH) && (DBL_MANT_DIG != LDBL_MANT_DIG))) \ && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS) -//# define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS +# define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS #endif #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) // @@ -209,7 +209,7 @@ // constexpr support, early GCC implementations can't cope so disable // constexpr for them: // -#if !defined(__clang) && defined(__GNUC__) +#if !defined(__clang__) && defined(__GNUC__) #if (__GNUC__ * 100 + __GNUC_MINOR__) < 490 # define BOOST_MATH_DISABLE_CONSTEXPR #endif @@ -451,6 +451,17 @@ namespace boost{ namespace math{ # define BOOST_MATH_THREAD_LOCAL #endif +// +// Can we have constexpr tables? +// +#if (!defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_CXX14_CONSTEXPR)) || BOOST_WORKAROUND(BOOST_MSVC, >= 1910) +#define BOOST_MATH_HAVE_CONSTEXPR_TABLES +#define BOOST_MATH_CONSTEXPR_TABLE_FUNCTION constexpr +#else +#define BOOST_MATH_CONSTEXPR_TABLE_FUNCTION +#endif + + #endif // BOOST_MATH_TOOLS_CONFIG_HPP diff --git a/3rdparty/boost/boost/move/adl_move_swap.hpp b/3rdparty/boost/boost/move/adl_move_swap.hpp index d6906a483f..d9096e36c3 100644 --- a/3rdparty/boost/boost/move/adl_move_swap.hpp +++ b/3rdparty/boost/boost/move/adl_move_swap.hpp @@ -261,6 +261,12 @@ BidirIt2 adl_move_swap_ranges_backward(BidirIt1 first1, BidirIt1 last1, BidirIt2 return last2; } +template +void adl_move_iter_swap(ForwardIt1 a, ForwardIt2 b) +{ + boost::adl_move_swap(*a, *b); +} + } //namespace boost{ #endif //#ifndef BOOST_MOVE_ADL_MOVE_SWAP_HPP diff --git a/3rdparty/boost/boost/move/core.hpp b/3rdparty/boost/boost/move/core.hpp index 1dd8a8c271..c0f5be59d4 100644 --- a/3rdparty/boost/boost/move/core.hpp +++ b/3rdparty/boost/boost/move/core.hpp @@ -57,22 +57,10 @@ #include - #if defined(BOOST_MOVE_ADDRESS_SANITIZER_ON) - #define BOOST_MOVE_TO_RV_CAST(RV_TYPE, ARG) reinterpret_cast(ARG) - #else - #define BOOST_MOVE_TO_RV_CAST(RV_TYPE, ARG) static_cast(ARG) - #endif + #define BOOST_MOVE_TO_RV_CAST(RV_TYPE, ARG) reinterpret_cast(ARG) //Move emulation rv breaks standard aliasing rules so add workarounds for some compilers - #if defined(__GNUC__) && (__GNUC__ >= 4) && \ - (\ - defined(BOOST_GCC) || \ - (defined(BOOST_INTEL) && (BOOST_INTEL_CXX_VERSION >= 1300)) \ - ) - #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__)) - #else - #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS - #endif + #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS BOOST_MAY_ALIAS namespace boost { diff --git a/3rdparty/boost/boost/move/detail/type_traits.hpp b/3rdparty/boost/boost/move/detail/type_traits.hpp index 1b5d8388e4..a3326d00e1 100644 --- a/3rdparty/boost/boost/move/detail/type_traits.hpp +++ b/3rdparty/boost/boost/move/detail/type_traits.hpp @@ -967,14 +967,13 @@ typedef union max_align max_align_t; #if !defined(BOOST_NO_ALIGNMENT) template -struct aligned_storage_impl; +struct aligned_struct; #define BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(A)\ template\ -struct BOOST_ALIGNMENT(A) aligned_storage_impl\ +struct BOOST_ALIGNMENT(A) aligned_struct\ {\ - char dummy[Len];\ - typedef aligned_storage_impl type;\ + char data[Len];\ };\ // @@ -995,13 +994,28 @@ BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000) #undef BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT +// Workaround for bogus [-Wignored-attributes] warning on GCC 6.x/7.x: don't use a type that "directly" carries the alignment attribute. +// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82270 +template +union aligned_struct_wrapper +{ + aligned_struct aligner; + char data[sizeof(aligned_struct)]; +}; + +template +struct aligned_storage_impl +{ + typedef aligned_struct_wrapper type; +}; + #else //BOOST_NO_ALIGNMENT template union aligned_union { T aligner; - char dummy[Len]; + char data[Len]; }; template diff --git a/3rdparty/boost/boost/mpl/assert.hpp b/3rdparty/boost/boost/mpl/assert.hpp index 4d860a4cae..e41b583c6d 100644 --- a/3rdparty/boost/boost/mpl/assert.hpp +++ b/3rdparty/boost/boost/mpl/assert.hpp @@ -56,7 +56,7 @@ // and GCC (which issues "unused variable" warnings when static constants are used // at a function scope) #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ - || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0) + || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0) || defined(__PGI) # define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) enum { expr } #else # define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) BOOST_STATIC_CONSTANT(T, expr) @@ -184,16 +184,27 @@ template< typename P > struct assert_arg_pred_not typedef typename assert_arg_pred_impl

::type type; }; +#if defined(BOOST_GCC) && BOOST_GCC >= 80000 +#define BOOST_MPL_IGNORE_PARENTHESES_WARNING +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wparentheses" +#endif + template< typename Pred > -failed ************ (Pred::************ +failed ************ (Pred::************ assert_arg( void (*)(Pred), typename assert_arg_pred::type ) ); template< typename Pred > -failed ************ (boost::mpl::not_::************ +failed ************ (boost::mpl::not_::************ assert_not_arg( void (*)(Pred), typename assert_arg_pred_not::type ) ); +#ifdef BOOST_MPL_IGNORE_PARENTHESES_WARNING +#undef BOOST_MPL_IGNORE_PARENTHESES_WARNING +#pragma GCC diagnostic pop +#endif + template< typename Pred > AUX778076_ASSERT_ARG(assert) assert_arg( void (*)(Pred), typename assert_arg_pred_not::type ); diff --git a/3rdparty/boost/boost/next_prior.hpp b/3rdparty/boost/boost/next_prior.hpp index bad46ed654..5de705f591 100644 --- a/3rdparty/boost/boost/next_prior.hpp +++ b/3rdparty/boost/boost/next_prior.hpp @@ -46,19 +46,34 @@ namespace next_prior_detail { // Since C++17 we can test for iterator_traits::iterator_category presence instead as it is // required to be only present for iterators. template< typename T, typename Void = void > -struct is_iterator +struct is_iterator_class { static BOOST_CONSTEXPR_OR_CONST bool value = false; }; template< typename T > -struct is_iterator< T, typename enable_if_has_type< typename T::iterator_category >::type > +struct is_iterator_class< + T, + typename enable_if_has_type< +#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS) + typename std::iterator_traits< T >::iterator_category +#else + typename T::iterator_category +#endif + >::type +> { static BOOST_CONSTEXPR_OR_CONST bool value = true; }; template< typename T > -struct is_iterator< T*, void > +struct is_iterator : + public is_iterator_class< T > +{ +}; + +template< typename T > +struct is_iterator< T* > { static BOOST_CONSTEXPR_OR_CONST bool value = true; }; diff --git a/3rdparty/boost/boost/numeric/conversion/cast.hpp b/3rdparty/boost/boost/numeric/conversion/cast.hpp index 1ee02518bc..61286c1311 100644 --- a/3rdparty/boost/boost/numeric/conversion/cast.hpp +++ b/3rdparty/boost/boost/numeric/conversion/cast.hpp @@ -23,7 +23,7 @@ #include -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) # include diff --git a/3rdparty/boost/boost/numeric/conversion/conversion_traits.hpp b/3rdparty/boost/boost/numeric/conversion/conversion_traits.hpp index 6da6178ad6..23e0eb8c9a 100644 --- a/3rdparty/boost/boost/numeric/conversion/conversion_traits.hpp +++ b/3rdparty/boost/boost/numeric/conversion/conversion_traits.hpp @@ -21,13 +21,6 @@ template struct conversion_traits : convdetail::get_conversion_traits::type { -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - typedef typename convdetail::get_conversion_traits::type base_; - typedef typename base_::target_type target_type; - typedef typename base_::source_type source_type; - typedef typename base_::result_type result_type; - typedef typename base_::argument_type argument_type; -#endif } ; } } // namespace boost::numeric diff --git a/3rdparty/boost/boost/numeric/conversion/detail/converter.hpp b/3rdparty/boost/boost/numeric/conversion/detail/converter.hpp index 10550f8daa..f7bf7b4436 100644 --- a/3rdparty/boost/boost/numeric/conversion/detail/converter.hpp +++ b/3rdparty/boost/boost/numeric/conversion/detail/converter.hpp @@ -450,13 +450,10 @@ namespace boost { namespace numeric { namespace convdetail // Trivial Converter : used when (cv-unqualified) T == (cv-unqualified) S // template - struct trivial_converter_impl : public std::unary_function< BOOST_DEDUCED_TYPENAME Traits::argument_type - ,BOOST_DEDUCED_TYPENAME Traits::result_type - > - ,public dummy_range_checker + struct trivial_converter_impl : public dummy_range_checker { typedef Traits traits ; - + typedef typename Traits::source_type source_type ; typedef typename Traits::argument_type argument_type ; typedef typename Traits::result_type result_type ; @@ -471,10 +468,7 @@ namespace boost { namespace numeric { namespace convdetail // Rounding Converter : used for float to integral conversions. // template - struct rounding_converter : public std::unary_function< BOOST_DEDUCED_TYPENAME Traits::argument_type - ,BOOST_DEDUCED_TYPENAME Traits::result_type - > - ,public RangeChecker + struct rounding_converter : public RangeChecker ,public Float2IntRounder ,public RawConverter { @@ -501,10 +495,7 @@ namespace boost { namespace numeric { namespace convdetail // Non-Rounding Converter : used for all other conversions. // template - struct non_rounding_converter : public std::unary_function< BOOST_DEDUCED_TYPENAME Traits::argument_type - ,BOOST_DEDUCED_TYPENAME Traits::result_type - > - ,public RangeChecker + struct non_rounding_converter : public RangeChecker ,public RawConverter { typedef RangeChecker RangeCheckerBase ; diff --git a/3rdparty/boost/boost/numeric/conversion/detail/old_numeric_cast.hpp b/3rdparty/boost/boost/numeric/conversion/detail/old_numeric_cast.hpp old mode 100755 new mode 100644 index 47b86d2c8c..9901ed2ae3 --- a/3rdparty/boost/boost/numeric/conversion/detail/old_numeric_cast.hpp +++ b/3rdparty/boost/boost/numeric/conversion/detail/old_numeric_cast.hpp @@ -8,6 +8,8 @@ // See http://www.boost.org/libs/conversion for Documentation. // Revision History +// 02 Jun 14 Remove VC6 workarounds. +// 16 Jul 11 Bugfixes for VC6. // 23 JUN 05 Code extracted from /boost/cast.hpp into this new header. // Keeps this legacy version of numeric_cast<> for old compilers // wich can't compile the new version in /boost/numeric/conversion/cast.hpp @@ -53,19 +55,6 @@ # include # include -// It has been demonstrated numerous times that MSVC 6.0 fails silently at link -// time if you use a template function which has template parameters that don't -// appear in the function's argument list. -// -// TODO: Add this to config.hpp? -// FLC: This macro is repeated in boost/cast.hpp but only locally (is undefined at the bottom) -// so is OK to reproduce it here. -# if defined(BOOST_MSVC) && BOOST_MSVC < 1300 -# define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type* = 0 -# else -# define BOOST_EXPLICIT_DEFAULT_TARGET -# endif - namespace boost { using numeric::bad_numeric_cast; @@ -214,24 +203,6 @@ namespace boost template static inline bool check(X x, Y) { return x >= 0 && static_cast(static_cast(x)) != x; } - -# if defined(BOOST_MSVC) && BOOST_MSVC < 1300 - // MSVC6 can't static_cast unsigned __int64 -> floating types -# define BOOST_UINT64_CAST(src_type) \ - static inline bool check(src_type x, unsigned __int64) \ - { \ - if (x < 0) return false; \ - unsigned __int64 y = static_cast(x); \ - bool odd = y & 0x1; \ - __int64 div2 = static_cast<__int64>(y >> 1); \ - return ((static_cast(div2) * 2.0) + odd) != x; \ - } - - BOOST_UINT64_CAST(long double); - BOOST_UINT64_CAST(double); - BOOST_UINT64_CAST(float); -# undef BOOST_UINT64_CAST -# endif }; template<> @@ -285,7 +256,7 @@ namespace boost #endif template - inline Target numeric_cast(Source arg BOOST_EXPLICIT_DEFAULT_TARGET) + inline Target numeric_cast(Source arg) { // typedefs abbreviating respective trait classes typedef detail::fixed_numeric_limits arg_traits; @@ -332,8 +303,6 @@ namespace boost return static_cast(arg); } // numeric_cast -# undef BOOST_EXPLICIT_DEFAULT_TARGET - } // namespace boost #endif // BOOST_OLD_NUMERIC_CAST_HPP diff --git a/3rdparty/boost/boost/optional/detail/old_optional_implementation.hpp b/3rdparty/boost/boost/optional/detail/old_optional_implementation.hpp index f2e6718402..62c31eeceb 100644 --- a/3rdparty/boost/boost/optional/detail/old_optional_implementation.hpp +++ b/3rdparty/boost/boost/optional/detail/old_optional_implementation.hpp @@ -147,7 +147,7 @@ class optional_base : public optional_tag } #endif - // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialzed optional. + // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional. // Can throw if T::T(T const&) does optional_base ( bool cond, argument_type val ) : @@ -730,7 +730,7 @@ class optional : public optional_detail::optional_base explicit optional ( Expr&& expr, BOOST_DEDUCED_TYPENAME boost::disable_if_c< (boost::is_base_of::type>::value) || - boost::is_same::type, none_t>::value >::type* = 0 + boost::is_same::type, none_t>::value, bool >::type = true ) : base(boost::forward(expr),boost::addressof(expr)) {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref();} @@ -746,12 +746,12 @@ class optional : public optional_detail::optional_base optional ( optional const& rhs ) : base( static_cast(rhs) ) {} #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES - // Creates a deep move of another optional - // Can throw if T::T(T&&) does - optional ( optional && rhs ) - BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value) - : base( boost::move(rhs) ) - {} + // Creates a deep move of another optional + // Can throw if T::T(T&&) does + optional ( optional && rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value) + : base( boost::move(rhs) ) + {} #endif // No-throw (assuming T::~T() doesn't) @@ -819,7 +819,7 @@ class optional : public optional_detail::optional_base #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES // Assigns from another optional (deep-moves the rhs value) optional& operator= ( optional && rhs ) - BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) { this->assign( static_cast(rhs) ) ; return *this ; @@ -892,7 +892,7 @@ class optional : public optional_detail::optional_base #endif void swap( optional & arg ) - BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) { // allow for Koenig lookup boost::swap(*this, arg); diff --git a/3rdparty/boost/boost/optional/detail/optional_aligned_storage.hpp b/3rdparty/boost/boost/optional/detail/optional_aligned_storage.hpp index 6c7d58148e..2937349f52 100644 --- a/3rdparty/boost/boost/optional/detail/optional_aligned_storage.hpp +++ b/3rdparty/boost/boost/optional/detail/optional_aligned_storage.hpp @@ -25,12 +25,8 @@ template class aligned_storage { // Borland ICEs if unnamed unions are used for this! - union - // This works around GCC warnings about breaking strict aliasing rules when casting storage address to T* -#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) - __attribute__((__may_alias__)) -#endif - dummy_u + // BOOST_MAY_ALIAS works around GCC warnings about breaking strict aliasing rules when casting storage address to T* + union BOOST_MAY_ALIAS dummy_u { char data[ sizeof(T) ]; BOOST_DEDUCED_TYPENAME type_with_alignment< @@ -48,24 +44,24 @@ class aligned_storage #endif #if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) - // This workaround is supposed to silence GCC warnings about broken strict aliasing rules - T const* ptr_ref() const - { - union { void const* ap_pvoid; T const* as_ptype; } caster = { address() }; - return caster.as_ptype; - } - T * ptr_ref() - { - union { void* ap_pvoid; T* as_ptype; } caster = { address() }; - return caster.as_ptype; - } + // This workaround is supposed to silence GCC warnings about broken strict aliasing rules + T const* ptr_ref() const + { + union { void const* ap_pvoid; T const* as_ptype; } caster = { address() }; + return caster.as_ptype; + } + T * ptr_ref() + { + union { void* ap_pvoid; T* as_ptype; } caster = { address() }; + return caster.as_ptype; + } #else - T const* ptr_ref() const { return static_cast(address()); } - T * ptr_ref() { return static_cast (address()); } + T const* ptr_ref() const { return static_cast(address()); } + T * ptr_ref() { return static_cast (address()); } #endif - T const& ref() const { return *ptr_ref(); } - T & ref() { return *ptr_ref(); } + T const& ref() const { return *ptr_ref(); } + T & ref() { return *ptr_ref(); } } ; diff --git a/3rdparty/boost/boost/optional/detail/optional_config.hpp b/3rdparty/boost/boost/optional/detail/optional_config.hpp index e26d73c1b4..bb7e12f9fc 100644 --- a/3rdparty/boost/boost/optional/detail/optional_config.hpp +++ b/3rdparty/boost/boost/optional/detail/optional_config.hpp @@ -1,5 +1,5 @@ // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal. -// Copyright (C) 2015 Andrzej Krzemienski. +// Copyright (C) 2015 - 2017 Andrzej Krzemienski. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at @@ -44,11 +44,11 @@ # define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION #endif -#if defined(__GNUC__) && !defined(__INTEL_COMPILER) -// GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with -// regard to violation of the strict aliasing rules. The optional< T > storage type is marked -// with this attribute in order to let the compiler know that it will alias objects of type T -// and silence compilation warnings. +#if !defined(BOOST_NO_MAY_ALIAS) +// GCC since 3.3 and some other compilers have may_alias attribute that helps to alleviate +// optimizer issues with regard to violation of the strict aliasing rules. The optional< T > +// storage type is marked with this attribute in order to let the compiler know that it will +// alias objects of type T and silence compilation warnings. # define BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS #endif @@ -113,4 +113,23 @@ # define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS #endif + +// Detect suport for defaulting move operations +// (some older compilers implement rvalue references, +// defaulted funcitons but move operations are not special members and cannot be defaulted) + +#ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS +# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS +#elif BOOST_WORKAROUND(BOOST_MSVC, < 1900) +# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS +#elif BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40600) +# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS +#endif + + +#ifdef BOOST_OPTIONAL_CONFIG_NO_DIRECT_STORAGE_SPEC +# define BOOST_OPTIONAL_DETAIL_NO_DIRECT_STORAGE_SPEC +#endif + + #endif // header guard diff --git a/3rdparty/boost/boost/optional/detail/optional_reference_spec.hpp b/3rdparty/boost/boost/optional/detail/optional_reference_spec.hpp index ce558755a2..4be140c283 100644 --- a/3rdparty/boost/boost/optional/detail/optional_reference_spec.hpp +++ b/3rdparty/boost/boost/optional/detail/optional_reference_spec.hpp @@ -1,4 +1,4 @@ -// Copyright (C) 2015-2016 Andrzej Krzemienski. +// Copyright (C) 2015-2018 Andrzej Krzemienski. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at @@ -132,11 +132,11 @@ public: // the following two implement a 'conditionally explicit' constructor: condition is a hack for buggy compilers with srewed conversion construction from const int template - explicit optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c::value && detail::is_const_integral_bad_for_conversion::value>::type* = 0) BOOST_NOEXCEPT + explicit optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c::value && detail::is_const_integral_bad_for_conversion::value, bool>::type = true) BOOST_NOEXCEPT : ptr_(boost::addressof(rhs)) {} template - optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c::value && !detail::is_const_integral_bad_for_conversion::value>::type* = 0) BOOST_NOEXCEPT + optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c::value && !detail::is_const_integral_bad_for_conversion::value, bool>::type = true) BOOST_NOEXCEPT : ptr_(boost::addressof(rhs)) {} optional& operator=(const optional& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; } @@ -159,17 +159,36 @@ public: void reset() BOOST_NOEXCEPT { ptr_ = 0; } bool is_initialized() const BOOST_NOEXCEPT { return ptr_ != 0; } + bool has_value() const BOOST_NOEXCEPT { return ptr_ != 0; } + + template + optional::type> map(F f) const + { + if (this->has_value()) + return f(this->get()); + else + return none; + } + + template + optional::type>::type> flat_map(F f) const + { + if (this->has_value()) + return f(get()); + else + return none; + } #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES optional(T&& /* rhs */) BOOST_NOEXCEPT { detail::prevent_binding_rvalue(); } template - optional(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + optional(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) BOOST_NOEXCEPT : ptr_(boost::addressof(r)) { detail::prevent_binding_rvalue(); } template - optional(bool cond, R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + optional(bool cond, R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(r) : 0) { detail::prevent_binding_rvalue(); } template @@ -177,19 +196,19 @@ public: operator=(R&& r) BOOST_NOEXCEPT { detail::prevent_binding_rvalue(); ptr_ = boost::addressof(r); return *this; } template - void emplace(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + void emplace(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) BOOST_NOEXCEPT { detail::prevent_binding_rvalue(); ptr_ = boost::addressof(r); } template - T& get_value_or(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) const BOOST_NOEXCEPT + T& get_value_or(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) const BOOST_NOEXCEPT { detail::prevent_binding_rvalue(); return ptr_ ? *ptr_ : r; } template - T& value_or(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) const BOOST_NOEXCEPT + T& value_or(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) const BOOST_NOEXCEPT { detail::prevent_binding_rvalue(); return ptr_ ? *ptr_ : r; } template - void reset(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + void reset(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) BOOST_NOEXCEPT { detail::prevent_binding_rvalue(); ptr_ = boost::addressof(r); } template @@ -200,15 +219,15 @@ public: // the following two implement a 'conditionally explicit' constructor template - explicit optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if_c::value && detail::is_const_integral_bad_for_conversion::value >::type* = 0) BOOST_NOEXCEPT + explicit optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if_c::value && detail::is_const_integral_bad_for_conversion::value, bool>::type = true) BOOST_NOEXCEPT : ptr_(boost::addressof(v)) { } template - optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if_c::value && !detail::is_const_integral_bad_for_conversion::value >::type* = 0) BOOST_NOEXCEPT + optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if_c::value && !detail::is_const_integral_bad_for_conversion::value, bool>::type = true) BOOST_NOEXCEPT : ptr_(boost::addressof(v)) { } template - optional(bool cond, U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(v) : 0) {} + optional(bool cond, U& v, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(v) : 0) {} template BOOST_DEDUCED_TYPENAME boost::enable_if, optional&>::type @@ -219,19 +238,19 @@ public: } template - void emplace(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + void emplace(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) BOOST_NOEXCEPT { ptr_ = boost::addressof(v); } template - T& get_value_or(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) const BOOST_NOEXCEPT + T& get_value_or(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) const BOOST_NOEXCEPT { return ptr_ ? *ptr_ : v; } template - T& value_or(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) const BOOST_NOEXCEPT + T& value_or(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) const BOOST_NOEXCEPT { return ptr_ ? *ptr_ : v; } template - void reset(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if >::type* = 0) BOOST_NOEXCEPT + void reset(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if, bool>::type = true) BOOST_NOEXCEPT { ptr_ = boost::addressof(v); } template diff --git a/3rdparty/boost/boost/optional/detail/optional_relops.hpp b/3rdparty/boost/boost/optional/detail/optional_relops.hpp index 3f961179d7..2c17f2b727 100644 --- a/3rdparty/boost/boost/optional/detail/optional_relops.hpp +++ b/3rdparty/boost/boost/optional/detail/optional_relops.hpp @@ -26,7 +26,7 @@ namespace boost { template inline bool operator == ( optional const& x, optional const& y ) -{ return equal_pointees(x,y); } +{ return bool(x) && bool(y) ? *x == *y : bool(x) == bool(y); } template inline diff --git a/3rdparty/boost/boost/optional/detail/optional_trivially_copyable_base.hpp b/3rdparty/boost/boost/optional/detail/optional_trivially_copyable_base.hpp new file mode 100644 index 0000000000..91328ac4e7 --- /dev/null +++ b/3rdparty/boost/boost/optional/detail/optional_trivially_copyable_base.hpp @@ -0,0 +1,499 @@ +// trivilally-copyable version of the storage + +template +class tc_optional_base : public optional_tag +{ + private : + + typedef tc_optional_base this_type ; + + protected : + + typedef T value_type ; + + protected: + typedef T & reference_type ; + typedef T const& reference_const_type ; +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + typedef T && rval_reference_type ; + typedef T && reference_type_of_temporary_wrapper ; +#endif + typedef T * pointer_type ; + typedef T const* pointer_const_type ; + typedef T const& argument_type ; + + tc_optional_base() + : + m_initialized(false) {} + + tc_optional_base ( none_t ) + : + m_initialized(false) {} + + tc_optional_base ( argument_type val ) + : + m_initialized(true), m_storage(val) {} + + tc_optional_base ( bool cond, argument_type val ) + : + m_initialized(cond), m_storage(val) {} + + // tc_optional_base ( tc_optional_base const& ) = default; + + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + template + explicit tc_optional_base ( Expr&& expr, PtrExpr const* tag ) + : + m_initialized(false) + { + construct(boost::forward(expr),tag); + } + +#else + // This is used for both converting and in-place constructions. + // Derived classes use the 'tag' to select the appropriate + // implementation (the correct 'construct()' overload) + template + explicit tc_optional_base ( Expr const& expr, Expr const* tag ) + : + m_initialized(false) + { + construct(expr,tag); + } + +#endif + + // tc_optional_base& operator= ( tc_optional_base const& ) = default; + // ~tc_optional_base() = default; + + // Assigns from another optional (deep-copies the rhs value) + void assign ( tc_optional_base const& rhs ) + { + this->operator=(rhs); + } + + // Assigns from another _convertible_ optional (deep-copies the rhs value) + template + void assign ( optional const& rhs ) + { + if ( rhs.is_initialized() ) +#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES + m_storage = rhs.get(); +#else + m_storage = static_cast(rhs.get()); +#endif + + m_initialized = rhs.is_initialized(); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // move-assigns from another _convertible_ optional (deep-moves from the rhs value) + template + void assign ( optional&& rhs ) + { + typedef BOOST_DEDUCED_TYPENAME optional::rval_reference_type ref_type; + if ( rhs.is_initialized() ) + m_storage = static_cast(rhs.get()); + m_initialized = rhs.is_initialized(); + } +#endif + + void assign ( argument_type val ) + { + construct(val); + } + + void assign ( none_t ) { destroy(); } + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + template + void assign_expr ( Expr&& expr, ExprPtr const* tag ) + { + construct(boost::forward(expr),tag); + } +#else + template + void assign_expr ( Expr const& expr, Expr const* tag ) + { + construct(expr,tag); + } +#endif + +#endif + + public : + + // **DEPPRECATED** Destroys the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + void reset() BOOST_NOEXCEPT { destroy(); } + + // **DEPPRECATED** Replaces the current value -if any- with 'val' + void reset ( argument_type val ) BOOST_NOEXCEPT { assign(val); } + + // Returns a pointer to the value if this is initialized, otherwise, + // returns NULL. + // No-throw + pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; } + pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; } + + bool is_initialized() const { return m_initialized ; } + + protected : + + void construct ( argument_type val ) + { + m_storage = val ; + m_initialized = true ; + } + + +#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES) + // Constructs in-place + // upon exception *this is always uninitialized + template + void construct ( in_place_init_t, Args&&... args ) + { + m_storage = value_type( boost::forward(args)... ) ; + m_initialized = true ; + } + + template + void emplace_assign ( Args&&... args ) + { + construct(in_place_init, boost::forward(args)...); + } + + template + explicit tc_optional_base ( in_place_init_t, Args&&... args ) + : + m_initialized(false) + { + construct(in_place_init, boost::forward(args)...); + } + + template + explicit tc_optional_base ( in_place_init_if_t, bool cond, Args&&... args ) + : + m_initialized(false) + { + if ( cond ) + construct(in_place_init, boost::forward(args)...); + } +#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) + template + void construct ( in_place_init_t, Arg&& arg ) + { + m_storage = value_type( boost::forward(arg) ); + m_initialized = true ; + } + + void construct ( in_place_init_t ) + { + m_storage = value_type(); + m_initialized = true ; + } + + template + void emplace_assign ( Arg&& arg ) + { + construct(in_place_init, boost::forward(arg)) ; + } + + void emplace_assign () + { + construct(in_place_init) ; + } + + template + explicit tc_optional_base ( in_place_init_t, Arg&& arg ) + : + m_initialized(false) + { + construct(in_place_init, boost::forward(arg)); + } + + explicit tc_optional_base ( in_place_init_t ) + : + m_initialized(false), m_storage() {} + + template + explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg&& arg ) + : + m_initialized(false) + { + if ( cond ) + construct(in_place_init, boost::forward(arg)); + } + + explicit tc_optional_base ( in_place_init_if_t, bool cond ) + : + m_initialized(false) + { + if ( cond ) + construct(in_place_init); + } + +#else + + template + void construct ( in_place_init_t, const Arg& arg ) + { + m_storage = value_type( arg ); + m_initialized = true ; + } + + template + void construct ( in_place_init_t, Arg& arg ) + { + m_storage = value_type( arg ); + m_initialized = true ; + } + + void construct ( in_place_init_t ) + { + m_storage = value_type(); + m_initialized = true ; + } + + template + void emplace_assign ( const Arg& arg ) + { + construct(in_place_init, arg); + } + + template + void emplace_assign ( Arg& arg ) + { + construct(in_place_init, arg); + } + + void emplace_assign () + { + construct(in_place_init); + } + + template + explicit tc_optional_base ( in_place_init_t, const Arg& arg ) + : m_initialized(false) + { + construct(in_place_init, arg); + } + + template + explicit tc_optional_base ( in_place_init_t, Arg& arg ) + : m_initialized(false) + { + construct(in_place_init, arg); + } + + explicit tc_optional_base ( in_place_init_t ) + : m_initialized(false) + { + construct(in_place_init); + } + + template + explicit tc_optional_base ( in_place_init_if_t, bool cond, const Arg& arg ) + : m_initialized(false) + { + if ( cond ) + construct(in_place_init, arg); + } + + template + explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg& arg ) + : m_initialized(false) + { + if ( cond ) + construct(in_place_init, arg); + } + + explicit tc_optional_base ( in_place_init_if_t, bool cond ) + : m_initialized(false) + { + if ( cond ) + construct(in_place_init); + } +#endif + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Constructs in-place using the given factory + template + void construct ( Expr&& factory, in_place_factory_base const* ) + { + boost_optional_detail::construct(factory, boost::addressof(m_storage)); + m_initialized = true ; + } + + // Constructs in-place using the given typed factory + template + void construct ( Expr&& factory, typed_in_place_factory_base const* ) + { + factory.apply(boost::addressof(m_storage)) ; + m_initialized = true ; + } + + template + void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + + // Constructs in-place using the given typed factory + template + void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + +#else + // Constructs in-place using the given factory + template + void construct ( Expr const& factory, in_place_factory_base const* ) + { + boost_optional_detail::construct(factory, m_storage.address()); + m_initialized = true ; + } + + // Constructs in-place using the given typed factory + template + void construct ( Expr const& factory, typed_in_place_factory_base const* ) + { + factory.apply(boost::addressof(m_storage)) ; + m_initialized = true ; + } + + template + void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + + // Constructs in-place using the given typed factory + template + void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } +#endif + +#endif + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Constructs using any expression implicitly convertible to the single argument + // of a one-argument T constructor. + // Converting constructions of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting constructor of T from U. + template + void construct ( Expr&& expr, void const* ) + { + m_storage = value_type(boost::forward(expr)) ; + m_initialized = true ; + } + + // Assigns using a form any expression implicitly convertible to the single argument + // of a T's assignment operator. + // Converting assignments of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting assignment of T from U. + template + void assign_expr_to_initialized ( Expr&& expr, void const* ) + { + assign_value( boost::forward(expr) ); + } +#else + // Constructs using any expression implicitly convertible to the single argument + // of a one-argument T constructor. + // Converting constructions of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting constructor of T from U. + template + void construct ( Expr const& expr, void const* ) + { + m_storage = value_type(expr) ; + m_initialized = true ; + } + + // Assigns using a form any expression implicitly convertible to the single argument + // of a T's assignment operator. + // Converting assignments of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting assignment of T from U. + template + void assign_expr_to_initialized ( Expr const& expr, void const* ) + { + assign_value(expr); + } + +#endif + +#ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION + // BCB5.64 (and probably lower versions) workaround. + // The in-place factories are supported by means of catch-all constructors + // and assignment operators (the functions are parameterized in terms of + // an arbitrary 'Expr' type) + // This compiler incorrectly resolves the overload set and sinks optional and optional + // to the 'Expr'-taking functions even though explicit overloads are present for them. + // Thus, the following overload is needed to properly handle the case when the 'lhs' + // is another optional. + // + // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error + // instead of choosing the wrong overload + // +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Notice that 'Expr' will be optional or optional (but not tc_optional_base<..>) + template + void construct ( Expr&& expr, optional_tag const* ) + { + if ( expr.is_initialized() ) + { + // An exception can be thrown here. + // It it happens, THIS will be left uninitialized. + m_storage = value_type(boost::move(expr.get())) ; + m_initialized = true ; + } + } +#else + // Notice that 'Expr' will be optional or optional (but not tc_optional_base<..>) + template + void construct ( Expr const& expr, optional_tag const* ) + { + if ( expr.is_initialized() ) + { + // An exception can be thrown here. + // It it happens, THIS will be left uninitialized. + m_storage = value_type(expr.get()) ; + m_initialized = true ; + } + } +#endif +#endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION + + void assign_value ( argument_type val ) { m_storage = val; } +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + void assign_value ( rval_reference_type val ) { m_storage = static_cast(val); } +#endif + + void destroy() + { + m_initialized = false; + } + + reference_const_type get_impl() const { return m_storage ; } + reference_type get_impl() { return m_storage ; } + + pointer_const_type get_ptr_impl() const { return boost::addressof(m_storage); } + pointer_type get_ptr_impl() { return boost::addressof(m_storage); } + + private : + + bool m_initialized ; + T m_storage ; +} ; diff --git a/3rdparty/boost/boost/optional/optional.hpp b/3rdparty/boost/boost/optional/optional.hpp index a465b9ed66..01cb2bda1f 100644 --- a/3rdparty/boost/boost/optional/optional.hpp +++ b/3rdparty/boost/boost/optional/optional.hpp @@ -1,5 +1,5 @@ // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal. -// Copyright (C) 2014 - 2016 Andrzej Krzemienski. +// Copyright (C) 2014 - 2018 Andrzej Krzemienski. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at @@ -20,6 +20,10 @@ #include #include +#ifdef BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS +# include +#endif + #include #include #include @@ -37,44 +41,63 @@ #include #include #include +#include #include #include #include #include #include #include +#include +#include #include #include #include +#include #include #include #include #include +namespace boost { namespace optional_detail { + +template +struct optional_value_type +{ +}; + +template +struct optional_value_type< ::boost::optional > +{ + typedef T type; +}; + +}} // namespace boost::optional_detail + #ifdef BOOST_OPTIONAL_CONFIG_USE_OLD_IMPLEMENTATION_OF_OPTIONAL #include #else namespace boost { - + namespace optional_ns { - + // a tag for in-place initialization of contained value struct in_place_init_t { struct init_tag{}; explicit in_place_init_t(init_tag){} -}; +}; const in_place_init_t in_place_init ((in_place_init_t::init_tag())); -// a tag for conditional in-place initialization of contained value +// a tag for conditional in-place initialization of contained value struct in_place_init_if_t { struct init_tag{}; explicit in_place_init_if_t(init_tag){} }; const in_place_init_if_t in_place_init_if ((in_place_init_if_t::init_tag())); - + } // namespace optional_ns using optional_ns::in_place_init_t; @@ -142,7 +165,7 @@ class optional_base : public optional_tag } #endif - // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialzed optional. + // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional. // Can throw if T::T(T const&) does optional_base ( bool cond, argument_type val ) : @@ -152,6 +175,18 @@ class optional_base : public optional_tag construct(val); } +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates an optional initialized with 'move(val)' IFF cond is true, otherwise creates an uninitialized optional. + // Can throw if T::T(T &&) does + optional_base ( bool cond, rval_reference_type val ) + : + m_initialized(false) + { + if ( cond ) + construct(boost::move(val)); + } +#endif + // Creates a deep copy of another optional // Can throw if T::T(T const&) does optional_base ( optional_base const& rhs ) @@ -166,6 +201,7 @@ class optional_base : public optional_tag // Creates a deep move of another optional // Can throw if T::T(T&&) does optional_base ( optional_base&& rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value) : m_initialized(false) { @@ -198,6 +234,20 @@ class optional_base : public optional_tag #endif + optional_base& operator= ( optional_base const& rhs ) + { + this->assign(rhs); + return *this; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + optional_base& operator= ( optional_base && rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) + { + this->assign(static_cast(rhs)); + return *this; + } +#endif // No-throw (assuming T::~T() doesn't) ~optional_base() { destroy() ; } @@ -217,7 +267,7 @@ class optional_base : public optional_tag construct(rhs.get_impl()); } } - + #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES // Assigns from another optional (deep-moves the rhs value) void assign ( optional_base&& rhs ) @@ -234,7 +284,7 @@ class optional_base : public optional_tag construct(boost::move(rhs.get_impl())); } } -#endif +#endif // Assigns from another _convertible_ optional (deep-copies the rhs value) template @@ -248,7 +298,7 @@ class optional_base : public optional_tag #else assign_value( static_cast(rhs.get()) ); #endif - + else destroy(); } else @@ -281,7 +331,7 @@ class optional_base : public optional_tag } } #endif - + // Assigns from a T (deep-copies the rhs value) void assign ( argument_type val ) { @@ -289,7 +339,7 @@ class optional_base : public optional_tag assign_value(val); else construct(val); } - + #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES // Assigns from a T (deep-moves the rhs value) void assign ( rval_reference_type val ) @@ -341,7 +391,7 @@ class optional_base : public optional_tag pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; } pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; } - bool is_initialized() const { return m_initialized ; } + bool is_initialized() const BOOST_NOEXCEPT { return m_initialized ; } protected : @@ -350,7 +400,7 @@ class optional_base : public optional_tag ::new (m_storage.address()) value_type(val) ; m_initialized = true ; } - + #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES void construct ( rval_reference_type val ) { @@ -376,7 +426,7 @@ class optional_base : public optional_tag destroy(); construct(in_place_init, boost::forward(args)...); } - + template explicit optional_base ( in_place_init_t, Args&&... args ) : @@ -384,7 +434,7 @@ class optional_base : public optional_tag { construct(in_place_init, boost::forward(args)...); } - + template explicit optional_base ( in_place_init_if_t, bool cond, Args&&... args ) : @@ -400,26 +450,26 @@ class optional_base : public optional_tag ::new (m_storage.address()) value_type( boost::forward(arg) ); m_initialized = true ; } - + void construct ( in_place_init_t ) { ::new (m_storage.address()) value_type(); m_initialized = true ; } - + template void emplace_assign ( Arg&& arg ) { destroy(); construct(in_place_init, boost::forward(arg)) ; } - + void emplace_assign () { destroy(); construct(in_place_init) ; } - + template explicit optional_base ( in_place_init_t, Arg&& arg ) : @@ -427,14 +477,14 @@ class optional_base : public optional_tag { construct(in_place_init, boost::forward(arg)); } - + explicit optional_base ( in_place_init_t ) : m_initialized(false) { construct(in_place_init); } - + template explicit optional_base ( in_place_init_if_t, bool cond, Arg&& arg ) : @@ -443,7 +493,7 @@ class optional_base : public optional_tag if ( cond ) construct(in_place_init, boost::forward(arg)); } - + explicit optional_base ( in_place_init_if_t, bool cond ) : m_initialized(false) @@ -453,21 +503,21 @@ class optional_base : public optional_tag } #else - + template void construct ( in_place_init_t, const Arg& arg ) { ::new (m_storage.address()) value_type( arg ); m_initialized = true ; } - + template void construct ( in_place_init_t, Arg& arg ) { ::new (m_storage.address()) value_type( arg ); m_initialized = true ; } - + void construct ( in_place_init_t ) { ::new (m_storage.address()) value_type(); @@ -480,20 +530,20 @@ class optional_base : public optional_tag destroy(); construct(in_place_init, arg); } - + template void emplace_assign ( Arg& arg ) { destroy(); construct(in_place_init, arg); } - + void emplace_assign () { destroy(); construct(in_place_init); } - + template explicit optional_base ( in_place_init_t, const Arg& arg ) : m_initialized(false) @@ -507,13 +557,13 @@ class optional_base : public optional_tag { construct(in_place_init, arg); } - + explicit optional_base ( in_place_init_t ) : m_initialized(false) { construct(in_place_init); } - + template explicit optional_base ( in_place_init_if_t, bool cond, const Arg& arg ) : m_initialized(false) @@ -521,15 +571,15 @@ class optional_base : public optional_tag if ( cond ) construct(in_place_init, arg); } - + template explicit optional_base ( in_place_init_if_t, bool cond, Arg& arg ) : m_initialized(false) { if ( cond ) construct(in_place_init, arg); - } - + } + explicit optional_base ( in_place_init_if_t, bool cond ) : m_initialized(false) { @@ -713,7 +763,7 @@ class optional_base : public optional_tag private : -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600) +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1900)) void destroy_impl ( ) { m_storage.ptr_ref()->~T() ; m_initialized = false ; } #else void destroy_impl ( ) { m_storage.ref().T::~T() ; m_initialized = false ; } @@ -723,6 +773,8 @@ class optional_base : public optional_tag storage_type m_storage ; } ; +#include + // definition of metafunciton is_optional_val_init_candidate template struct is_optional_related @@ -734,7 +786,7 @@ struct is_optional_related {}; #if !defined(BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT) - + template struct is_convertible_to_T_or_factory : boost::conditional< boost::is_base_of::type>::value @@ -764,13 +816,34 @@ struct is_optional_val_init_candidate : boost::conditional< !is_optional_related::value && is_convertible_to_T_or_factory::value , boost::true_type, boost::false_type>::type {}; - + } // namespace optional_detail +namespace optional_config { + +template +struct optional_uses_direct_storage_for + : boost::conditional<(boost::is_scalar::value && !boost::is_const::value && !boost::is_volatile::value) + , boost::true_type, boost::false_type>::type +{}; + +} // namespace optional_config + + +#ifndef BOOST_OPTIONAL_DETAIL_NO_DIRECT_STORAGE_SPEC +# define BOOST_OPTIONAL_BASE_TYPE(T) boost::conditional< optional_config::optional_uses_direct_storage_for::value, \ + optional_detail::tc_optional_base, \ + optional_detail::optional_base \ + >::type +#else +# define BOOST_OPTIONAL_BASE_TYPE(T) optional_detail::optional_base +#endif + template -class optional : public optional_detail::optional_base +class optional + : public BOOST_OPTIONAL_BASE_TYPE(T) { - typedef optional_detail::optional_base base ; + typedef typename BOOST_OPTIONAL_BASE_TYPE(T) base ; public : @@ -802,7 +875,7 @@ class optional : public optional_detail::optional_base #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES // Creates an optional initialized with 'move(val)'. // Can throw if T::T(T &&) does - optional ( rval_reference_type val ) : base( boost::forward(val) ) + optional ( rval_reference_type val ) : base( boost::forward(val) ) {} #endif @@ -810,6 +883,13 @@ class optional : public optional_detail::optional_base // Can throw if T::T(T const&) does optional ( bool cond, argument_type val ) : base(cond,val) {} +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + /// Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional. + // Can throw if T::T(T &&) does + optional ( bool cond, rval_reference_type val ) : base( cond, boost::forward(val) ) + {} +#endif + // NOTE: MSVC needs templated versions first // Creates a deep copy of another convertible optional @@ -818,7 +898,7 @@ class optional : public optional_detail::optional_base template explicit optional ( optional const& rhs #ifndef BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS - ,typename boost::enable_if< optional_detail::is_optional_constructible >::type* = 0 + ,BOOST_DEDUCED_TYPENAME boost::enable_if< optional_detail::is_optional_constructible, bool>::type = true #endif ) : @@ -827,7 +907,7 @@ class optional : public optional_detail::optional_base if ( rhs.is_initialized() ) this->construct(rhs.get()); } - + #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES // Creates a deep move of another convertible optional // Requires a valid conversion from U to T. @@ -835,7 +915,7 @@ class optional : public optional_detail::optional_base template explicit optional ( optional && rhs #ifndef BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS - ,typename boost::enable_if< optional_detail::is_optional_constructible >::type* = 0 + ,BOOST_DEDUCED_TYPENAME boost::enable_if< optional_detail::is_optional_constructible, bool>::type = true #endif ) : @@ -860,10 +940,10 @@ class optional : public optional_detail::optional_base template - explicit optional ( Expr&& expr, - BOOST_DEDUCED_TYPENAME boost::enable_if< optional_detail::is_optional_val_init_candidate >::type* = 0 - ) - : base(boost::forward(expr),boost::addressof(expr)) + explicit optional ( Expr&& expr, + BOOST_DEDUCED_TYPENAME boost::enable_if< optional_detail::is_optional_val_init_candidate, bool>::type = true + ) + : base(boost::forward(expr),boost::addressof(expr)) {} #else @@ -874,15 +954,24 @@ class optional : public optional_detail::optional_base // Creates a deep copy of another optional // Can throw if T::T(T const&) does +#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS + optional ( optional const& ) = default; +#else optional ( optional const& rhs ) : base( static_cast(rhs) ) {} +#endif #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES - // Creates a deep move of another optional - // Can throw if T::T(T&&) does - optional ( optional && rhs ) - BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value) - : base( boost::move(rhs) ) - {} + // Creates a deep move of another optional + // Can throw if T::T(T&&) does + +#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS + optional ( optional && rhs ) = default; +#else + optional ( optional && rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value) + : base( boost::move(rhs) ) + {} +#endif #endif @@ -891,14 +980,14 @@ class optional : public optional_detail::optional_base ~optional() {} #endif - + #if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION) // Assigns from an expression. See corresponding constructor. // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES template - BOOST_DEDUCED_TYPENAME boost::enable_if, optional&>::type + BOOST_DEDUCED_TYPENAME boost::enable_if, optional&>::type operator= ( Expr&& expr ) { this->assign_expr(boost::forward(expr),boost::addressof(expr)); @@ -924,7 +1013,7 @@ class optional : public optional_detail::optional_base this->assign(rhs); return *this ; } - + #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES // Move-assigns from another convertible optional (converts && deep-moves the rhs value) // Requires a valid conversion from U to T. @@ -940,22 +1029,31 @@ class optional : public optional_detail::optional_base // Assigns from another optional (deep-copies the rhs value) // Basic Guarantee: If T::T( T const& ) throws, this is left UNINITIALIZED // (NOTE: On BCB, this operator is not actually called and left is left UNMODIFIED in case of a throw) +#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS + optional& operator= ( optional const& rhs ) = default; +#else optional& operator= ( optional const& rhs ) { this->assign( static_cast(rhs) ) ; return *this ; } +#endif #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES // Assigns from another optional (deep-moves the rhs value) - optional& operator= ( optional && rhs ) - BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) +#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS + optional& operator= ( optional && ) = default; +#else + optional& operator= ( optional && rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) { this->assign( static_cast(rhs) ) ; return *this ; } #endif +#endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + #ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX // Assigns from a T (deep-moves/copies the rhs value) @@ -966,7 +1064,7 @@ class optional : public optional_detail::optional_base this->assign( boost::forward(val) ) ; return *this ; } - + #else // Assigns from a T (deep-copies the rhs value) @@ -976,7 +1074,7 @@ class optional : public optional_detail::optional_base this->assign( val ) ; return *this ; } - + #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES // Assigns from a T (deep-moves the rhs value) optional& operator= ( rval_reference_type val ) @@ -985,9 +1083,9 @@ class optional : public optional_detail::optional_base return *this ; } #endif - + #endif // BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX - + // Assigns from a "none" // Which destroys the current value, if any, leaving this UNINITIALIZED // No-throw (assuming T::~T() doesn't) @@ -996,7 +1094,7 @@ class optional : public optional_detail::optional_base this->assign( none_ ) ; return *this ; } - + #if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES) // Constructs in-place // upon exception *this is always uninitialized @@ -1005,29 +1103,29 @@ class optional : public optional_detail::optional_base { this->emplace_assign( boost::forward(args)... ); } - + template explicit optional ( in_place_init_t, Args&&... args ) : base( in_place_init, boost::forward(args)... ) {} - + template explicit optional ( in_place_init_if_t, bool cond, Args&&... args ) : base( in_place_init_if, cond, boost::forward(args)... ) {} - + #elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) template void emplace ( Arg&& arg ) { this->emplace_assign( boost::forward(arg) ); } - + void emplace () { this->emplace_assign(); } - + template explicit optional ( in_place_init_t, Args&& args ) : base( in_place_init, boost::forward(args) ) @@ -1036,12 +1134,12 @@ class optional : public optional_detail::optional_base explicit optional ( in_place_init_t ) : base( in_place_init ) {} - + template explicit optional ( in_place_init_if_t, bool cond, Args&& args ) : base( in_place_init_if, cond, boost::forward(args) ) {} - + explicit optional ( in_place_init_if_t, bool cond ) : base( in_place_init_if, cond ) {} @@ -1051,23 +1149,23 @@ class optional : public optional_detail::optional_base { this->emplace_assign( arg ); } - + template void emplace ( Arg& arg ) { this->emplace_assign( arg ); } - + void emplace () { this->emplace_assign(); } - + template explicit optional ( in_place_init_t, const Arg& arg ) : base( in_place_init, arg ) {} - + template explicit optional ( in_place_init_t, Arg& arg ) : base( in_place_init, arg ) @@ -1076,24 +1174,24 @@ class optional : public optional_detail::optional_base explicit optional ( in_place_init_t ) : base( in_place_init ) {} - + template explicit optional ( in_place_init_if_t, bool cond, const Arg& arg ) : base( in_place_init_if, cond, arg ) {} - + template explicit optional ( in_place_init_if_t, bool cond, Arg& arg ) : base( in_place_init_if, cond, arg ) - {} - + {} + explicit optional ( in_place_init_if_t, bool cond ) : base( in_place_init_if, cond ) {} #endif void swap( optional & arg ) - BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) { // allow for Koenig lookup boost::swap(*this, arg); @@ -1119,7 +1217,7 @@ class optional : public optional_detail::optional_base // Returns a reference to the value if this is initialized, otherwise, // the behaviour is UNDEFINED // No-throw -#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) +#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) reference_const_type operator *() const& { return this->get() ; } reference_type operator *() & { return this->get() ; } reference_type_of_temporary_wrapper operator *() && { return boost::move(this->get()) ; } @@ -1128,42 +1226,42 @@ class optional : public optional_detail::optional_base reference_type operator *() { return this->get() ; } #endif // !defined BOOST_NO_CXX11_REF_QUALIFIERS -#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) +#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) reference_const_type value() const& - { + { if (this->is_initialized()) return this->get() ; else throw_exception(bad_optional_access()); } - + reference_type value() & - { + { if (this->is_initialized()) return this->get() ; else throw_exception(bad_optional_access()); } - + reference_type_of_temporary_wrapper value() && - { + { if (this->is_initialized()) return boost::move(this->get()) ; else throw_exception(bad_optional_access()); } -#else +#else reference_const_type value() const - { + { if (this->is_initialized()) return this->get() ; else throw_exception(bad_optional_access()); } - + reference_type value() - { + { if (this->is_initialized()) return this->get() ; else @@ -1175,16 +1273,16 @@ class optional : public optional_detail::optional_base #ifndef BOOST_NO_CXX11_REF_QUALIFIERS template value_type value_or ( U&& v ) const& - { + { if (this->is_initialized()) return get(); else return boost::forward(v); } - + template - value_type value_or ( U&& v ) && - { + value_type value_or ( U&& v ) && + { if (this->is_initialized()) return boost::move(get()); else @@ -1192,7 +1290,7 @@ class optional : public optional_detail::optional_base } #elif !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES template - value_type value_or ( U&& v ) const + value_type value_or ( U&& v ) const { if (this->is_initialized()) return get(); @@ -1201,17 +1299,17 @@ class optional : public optional_detail::optional_base } #else template - value_type value_or ( U const& v ) const - { + value_type value_or ( U const& v ) const + { if (this->is_initialized()) return get(); else return v; } - + template - value_type value_or ( U& v ) const - { + value_type value_or ( U& v ) const + { if (this->is_initialized()) return get(); else @@ -1220,7 +1318,7 @@ class optional : public optional_detail::optional_base #endif -#ifndef BOOST_NO_CXX11_REF_QUALIFIERS +#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) template value_type value_or_eval ( F f ) const& { @@ -1229,7 +1327,7 @@ class optional : public optional_detail::optional_base else return f(); } - + template value_type value_or_eval ( F f ) && { @@ -1238,6 +1336,61 @@ class optional : public optional_detail::optional_base else return f(); } + + template + optional::type> map(F f) & + { + if (this->has_value()) + return f(get()); + else + return none; + } + + template + optional::type> map(F f) const& + { + if (this->has_value()) + return f(get()); + else + return none; + } + + template + optional::type> map(F f) && + { + if (this->has_value()) + return f(boost::move(this->get())); + else + return none; + } + + template + optional::type>::type> flat_map(F f) & + { + if (this->has_value()) + return f(get()); + else + return none; + } + + template + optional::type>::type> flat_map(F f) const& + { + if (this->has_value()) + return f(get()); + else + return none; + } + + template + optional::type>::type> flat_map(F f) && + { + if (this->has_value()) + return f(boost::move(get())); + else + return none; + } + #else template value_type value_or_eval ( F f ) const @@ -1247,10 +1400,49 @@ class optional : public optional_detail::optional_base else return f(); } + + template + optional::type> map(F f) + { + if (this->has_value()) + return f(get()); + else + return none; + } + + template + optional::type> map(F f) const + { + if (this->has_value()) + return f(get()); + else + return none; + } + + template + optional::type>::type> flat_map(F f) + { + if (this->has_value()) + return f(get()); + else + return none; + } + + template + optional::type>::type> flat_map(F f) const + { + if (this->has_value()) + return f(get()); + else + return none; + } + #endif - + + bool has_value() const BOOST_NOEXCEPT { return this->is_initialized() ; } + bool operator!() const BOOST_NOEXCEPT { return !this->is_initialized() ; } - + BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT() } ; @@ -1259,7 +1451,7 @@ class optional : public optional_detail::optional_base #endif // BOOST_OPTIONAL_CONFIG_USE_OLD_IMPLEMENTATION_OF_OPTIONAL namespace boost { - + #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES template class optional @@ -1276,6 +1468,25 @@ class optional namespace boost { +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + +template +inline +optional::type> make_optional ( T && v ) +{ + return optional::type>(boost::forward(v)); +} + +// Returns optional(cond,v) +template +inline +optional::type> make_optional ( bool cond, T && v ) +{ + return optional::type>(cond,boost::forward(v)); +} + +#else + // Returns optional(v) template inline @@ -1292,6 +1503,8 @@ optional make_optional ( bool cond, T const& v ) return optional(cond,v); } +#endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED. // No-throw template @@ -1367,14 +1580,14 @@ get_pointer ( optional& opt ) } // namespace boost namespace boost { - + // The following declaration prevents a bug where operator safe-bool is used upon streaming optional object if you forget the IO header. template std::basic_ostream& operator<<(std::basic_ostream& os, optional_detail::optional_tag const&) { BOOST_STATIC_ASSERT_MSG(sizeof(CharType) == 0, "If you want to output boost::optional, include header "); - return os; + return os; } } // namespace boost diff --git a/3rdparty/boost/boost/parameter.hpp b/3rdparty/boost/boost/parameter.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/overloads.hpp b/3rdparty/boost/boost/parameter/aux_/overloads.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/parameter_requirements.hpp b/3rdparty/boost/boost/parameter/aux_/parameter_requirements.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/preprocessor/flatten.hpp b/3rdparty/boost/boost/parameter/aux_/preprocessor/flatten.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/preprocessor/for_each.hpp b/3rdparty/boost/boost/parameter/aux_/preprocessor/for_each.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/result_of0.hpp b/3rdparty/boost/boost/parameter/aux_/result_of0.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/tag.hpp b/3rdparty/boost/boost/parameter/aux_/tag.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/template_keyword.hpp b/3rdparty/boost/boost/parameter/aux_/template_keyword.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/void.hpp b/3rdparty/boost/boost/parameter/aux_/void.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/aux_/yesno.hpp b/3rdparty/boost/boost/parameter/aux_/yesno.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/match.hpp b/3rdparty/boost/boost/parameter/match.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/parameter/parameters.hpp b/3rdparty/boost/boost/parameter/parameters.hpp old mode 100755 new mode 100644 diff --git a/3rdparty/boost/boost/predef/architecture.h b/3rdparty/boost/boost/predef/architecture.h index c433d437bd..120d557963 100644 --- a/3rdparty/boost/boost/predef/architecture.h +++ b/3rdparty/boost/boost/predef/architecture.h @@ -19,6 +19,7 @@ http://www.boost.org/LICENSE_1_0.txt) #include #include #include +#include #include #include #include diff --git a/3rdparty/boost/boost/predef/architecture/arm.h b/3rdparty/boost/boost/predef/architecture/arm.h index 76f9f947bd..96f89c86fd 100644 --- a/3rdparty/boost/boost/predef/architecture/arm.h +++ b/3rdparty/boost/boost/predef/architecture/arm.h @@ -32,6 +32,7 @@ http://www.boost.org/LICENSE_1_0.txt) [[`__arm64`] [8.0.0]] [[`__TARGET_ARCH_ARM`] [V.0.0]] [[`__TARGET_ARCH_THUMB`] [V.0.0]] + [[`__ARM_ARCH`] [V.0.0]] [[`_M_ARM`] [V.0.0]] [[`_M_ARM64`] [8.0.0]] ] @@ -41,6 +42,7 @@ http://www.boost.org/LICENSE_1_0.txt) #if defined(__arm__) || defined(__arm64) || defined(__thumb__) || \ defined(__TARGET_ARCH_ARM) || defined(__TARGET_ARCH_THUMB) || \ + defined(__ARM_ARCH) || \ defined(_M_ARM) || defined(_M_ARM64) # undef BOOST_ARCH_ARM # if !defined(BOOST_ARCH_ARM) && defined(__arm64) @@ -52,6 +54,9 @@ http://www.boost.org/LICENSE_1_0.txt) # if !defined(BOOST_ARCH_ARM) && defined(__TARGET_ARCH_THUMB) # define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(__TARGET_ARCH_THUMB,0,0) # endif +# if !defined(BOOST_ARCH_ARM) && defined(__ARM_ARCH) +# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(__ARM_ARCH,0,0) +# endif # if !defined(BOOST_ARCH_ARM) && defined(_M_ARM64) # define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(8,0,0) # endif diff --git a/3rdparty/boost/boost/predef/architecture/parisc.h b/3rdparty/boost/boost/predef/architecture/parisc.h index 7c7625f912..c75a1f3889 100644 --- a/3rdparty/boost/boost/predef/architecture/parisc.h +++ b/3rdparty/boost/boost/predef/architecture/parisc.h @@ -12,7 +12,7 @@ http://www.boost.org/LICENSE_1_0.txt) #include /*` -[heading `BOOST_ARCH_PARISK`] +[heading `BOOST_ARCH_PARISC`] [@http://en.wikipedia.org/wiki/PA-RISC_family HP/PA RISC] architecture. diff --git a/3rdparty/boost/boost/predef/architecture/ptx.h b/3rdparty/boost/boost/predef/architecture/ptx.h new file mode 100644 index 0000000000..335517b276 --- /dev/null +++ b/3rdparty/boost/boost/predef/architecture/ptx.h @@ -0,0 +1,44 @@ +/* +Copyright Benjamin Worpitz 2018 +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_PREDEF_ARCHITECTURE_PTX_H +#define BOOST_PREDEF_ARCHITECTURE_PTX_H + +#include +#include + +/*` +[heading `BOOST_ARCH_PTX`] + +[@https://en.wikipedia.org/wiki/Parallel_Thread_Execution PTX] architecture. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__CUDA_ARCH__`] [__predef_detection__]] + + [[`__CUDA_ARCH__`] [V.R.0]] + ] + */ + +#define BOOST_ARCH_PTX BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__CUDA_ARCH__) +# undef BOOST_ARCH_PTX +# define BOOST_ARCH_PTX BOOST_PREDEF_MAKE_10_VR0(__CUDA_ARCH__) +#endif + +#if BOOST_ARCH_PTX +# define BOOST_ARCH_PTX_AVAILABLE +#endif + +#define BOOST_ARCH_PTX_NAME "PTX" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_PTX,BOOST_ARCH_PTX_NAME) diff --git a/3rdparty/boost/boost/predef/compiler.h b/3rdparty/boost/boost/predef/compiler.h index 61a4c527ab..de1b4ab573 100644 --- a/3rdparty/boost/boost/predef/compiler.h +++ b/3rdparty/boost/boost/predef/compiler.h @@ -32,6 +32,7 @@ http://www.boost.org/LICENSE_1_0.txt) #include #include #include +#include #include #include #include diff --git a/3rdparty/boost/boost/predef/compiler/nvcc.h b/3rdparty/boost/boost/predef/compiler/nvcc.h new file mode 100644 index 0000000000..3c35ef7cd8 --- /dev/null +++ b/3rdparty/boost/boost/predef/compiler/nvcc.h @@ -0,0 +1,60 @@ +/* +Copyright Benjamin Worpitz 2018 +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_PREDEF_COMPILER_NVCC_H +#define BOOST_PREDEF_COMPILER_NVCC_H + +#include +#include + +/*` +[heading `BOOST_COMP_NVCC`] + +[@https://en.wikipedia.org/wiki/NVIDIA_CUDA_Compiler NVCC] compiler. +Version number available as major, minor, and patch beginning with version 7.5. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__NVCC__`] [__predef_detection__]] + + [[`__CUDACC_VER_MAJOR__`, `__CUDACC_VER_MINOR__`, `__CUDACC_VER_BUILD__`] [V.R.P]] + ] + */ + +#define BOOST_COMP_NVCC BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__NVCC__) +# if !defined(__CUDACC_VER_MAJOR__) || !defined(__CUDACC_VER_MINOR__) || !defined(__CUDACC_VER_BUILD__) +# define BOOST_COMP_NVCC_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# else +# define BOOST_COMP_NVCC_DETECTION BOOST_VERSION_NUMBER(__CUDACC_VER_MAJOR__, __CUDACC_VER_MINOR__, __CUDACC_VER_BUILD__) +# endif +#endif + +#ifdef BOOST_COMP_NVCC_DETECTION +# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED) +# define BOOST_COMP_NVCC_EMULATED BOOST_COMP_NVCC_DETECTION +# else +# undef BOOST_COMP_NVCC +# define BOOST_COMP_NVCC BOOST_COMP_NVCC_DETECTION +# endif +# define BOOST_COMP_NVCC_AVAILABLE +# include +#endif + +#define BOOST_COMP_NVCC_NAME "NVCC" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_NVCC,BOOST_COMP_NVCC_NAME) + +#ifdef BOOST_COMP_NVCC_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_NVCC_EMULATED,BOOST_COMP_NVCC_NAME) +#endif diff --git a/3rdparty/boost/boost/predef/language.h b/3rdparty/boost/boost/predef/language.h index 0a317d5ece..9ce3cc98b4 100644 --- a/3rdparty/boost/boost/predef/language.h +++ b/3rdparty/boost/boost/predef/language.h @@ -13,5 +13,6 @@ http://www.boost.org/LICENSE_1_0.txt) #include #include #include +#include #endif diff --git a/3rdparty/boost/boost/predef/language/cuda.h b/3rdparty/boost/boost/predef/language/cuda.h new file mode 100644 index 0000000000..5c5fed3081 --- /dev/null +++ b/3rdparty/boost/boost/predef/language/cuda.h @@ -0,0 +1,52 @@ +/* +Copyright Benjamin Worpitz 2018 +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_PREDEF_LANGUAGE_CUDA_H +#define BOOST_PREDEF_LANGUAGE_CUDA_H + +#include +#include + +/*` +[heading `BOOST_LANG_CUDA`] + +[@https://en.wikipedia.org/wiki/CUDA CUDA C/C++] language. +If available, the version is detected as VV.RR.P. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__CUDACC__`] [__predef_detection__]] + [[`__CUDA__`] [__predef_detection__]] + + [[`CUDA_VERSION`] [VV.RR.P]] + ] + */ + +#define BOOST_LANG_CUDA BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__CUDACC__) || defined(__CUDA__) +# undef BOOST_LANG_CUDA +# include +# if defined(CUDA_VERSION) +# define BOOST_LANG_CUDA BOOST_PREDEF_MAKE_10_VVRRP(CUDA_VERSION) +# else +# define BOOST_LANG_CUDA BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#if BOOST_LANG_CUDA +# define BOOST_LANG_CUDA_AVAILABLE +#endif + +#define BOOST_LANG_CUDA_NAME "CUDA C/C++" + + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_CUDA,BOOST_LANG_CUDA_NAME) diff --git a/3rdparty/boost/boost/predef/library/c.h b/3rdparty/boost/boost/predef/library/c.h index fa8841e827..7ca84cc079 100644 --- a/3rdparty/boost/boost/predef/library/c.h +++ b/3rdparty/boost/boost/predef/library/c.h @@ -12,6 +12,7 @@ http://www.boost.org/LICENSE_1_0.txt) #include +#include #include #include #include diff --git a/3rdparty/boost/boost/predef/library/c/cloudabi.h b/3rdparty/boost/boost/predef/library/c/cloudabi.h new file mode 100644 index 0000000000..e6acaee65d --- /dev/null +++ b/3rdparty/boost/boost/predef/library/c/cloudabi.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2017 James E. King III + * + * 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_PREDEF_LIBRARY_C_CLOUDABI_H +#define BOOST_PREDEF_LIBRARY_C_CLOUDABI_H + +#include +#include + +#include + +#if defined(__CloudABI__) +#include +#endif + +/*` +[heading `BOOST_LIB_C_CLOUDABI`] + +[@https://github.com/NuxiNL/cloudlibc cloudlibc] - CloudABI's standard C library. +Version number available as major, and minor. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__cloudlibc__`] [__predef_detection__]] + + [[`__cloudlibc_major__`, `__cloudlibc_minor__`] [V.R.0]] + ] + */ + +#define BOOST_LIB_C_CLOUDABI BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__cloudlibc__) +# undef BOOST_LIB_C_CLOUDABI +# define BOOST_LIB_C_CLOUDABI \ + BOOST_VERSION_NUMBER(__cloudlibc_major__,__cloudlibc_minor__,0) +#endif + +#if BOOST_LIB_C_CLOUDABI +# define BOOST_LIB_C_CLOUDABI_AVAILABLE +#endif + +#define BOOST_LIB_C_CLOUDABI_NAME "cloudlibc" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_CLOUDABI,BOOST_LIB_C_CLOUDABI_NAME) diff --git a/3rdparty/boost/boost/predef/make.h b/3rdparty/boost/boost/predef/make.h index 4f2f9ee761..fccd2d3cc9 100644 --- a/3rdparty/boost/boost/predef/make.h +++ b/3rdparty/boost/boost/predef/make.h @@ -46,10 +46,14 @@ Macros are: #define BOOST_PREDEF_MAKE_0X_VVRRPP(V) BOOST_VERSION_NUMBER((V&0xFF0000)>>16,(V&0xFF00)>>8,(V&0xFF)) /*` `BOOST_PREDEF_MAKE_10_VPPP(V)` */ #define BOOST_PREDEF_MAKE_10_VPPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,0,(V)%1000) +/*` `BOOST_PREDEF_MAKE_10_VR0(V)` */ +#define BOOST_PREDEF_MAKE_10_VR0(V) BOOST_VERSION_NUMBER(((V)/100)%10,((V)/10)%10,0) /*` `BOOST_PREDEF_MAKE_10_VRP(V)` */ #define BOOST_PREDEF_MAKE_10_VRP(V) BOOST_VERSION_NUMBER(((V)/100)%10,((V)/10)%10,(V)%10) /*` `BOOST_PREDEF_MAKE_10_VRP000(V)` */ #define BOOST_PREDEF_MAKE_10_VRP000(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/10000)%10,((V)/1000)%10) +/*` `BOOST_PREDEF_MAKE_10_VRPPPP(V)` */ +#define BOOST_PREDEF_MAKE_10_VRPPPP(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/10000)%10,(V)%10000) /*` `BOOST_PREDEF_MAKE_10_VRPP(V)` */ #define BOOST_PREDEF_MAKE_10_VRPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,((V)/100)%10,(V)%100) /*` `BOOST_PREDEF_MAKE_10_VRR(V)` */ @@ -62,8 +66,12 @@ Macros are: #define BOOST_PREDEF_MAKE_10_VV00(V) BOOST_VERSION_NUMBER(((V)/100)%100,0,0) /*` `BOOST_PREDEF_MAKE_10_VVRR(V)` */ #define BOOST_PREDEF_MAKE_10_VVRR(V) BOOST_VERSION_NUMBER(((V)/100)%100,(V)%100,0) +/*` `BOOST_PREDEF_MAKE_10_VVRRP(V)` */ +#define BOOST_PREDEF_MAKE_10_VVRRP(V) BOOST_VERSION_NUMBER(((V)/1000)%100,((V)/10)%100,(V)%10) /*` `BOOST_PREDEF_MAKE_10_VVRRPP(V)` */ #define BOOST_PREDEF_MAKE_10_VVRRPP(V) BOOST_VERSION_NUMBER(((V)/10000)%100,((V)/100)%100,(V)%100) +/*` `BOOST_PREDEF_MAKE_10_VVRRPPP(V)` */ +#define BOOST_PREDEF_MAKE_10_VVRRPPP(V) BOOST_VERSION_NUMBER(((V)/100000)%100,((V)/1000)%100,(V)%1000) /*` `BOOST_PREDEF_MAKE_10_VVRR0PP00(V)` */ #define BOOST_PREDEF_MAKE_10_VVRR0PP00(V) BOOST_VERSION_NUMBER(((V)/10000000)%100,((V)/100000)%100,((V)/100)%100) /*` `BOOST_PREDEF_MAKE_10_VVRR0PPPP(V)` */ diff --git a/3rdparty/boost/boost/predef/os/android.h b/3rdparty/boost/boost/predef/os/android.h index 00836e7fce..125dbded9e 100644 --- a/3rdparty/boost/boost/predef/os/android.h +++ b/3rdparty/boost/boost/predef/os/android.h @@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0. http://www.boost.org/LICENSE_1_0.txt) */ -#ifndef BOOST_PREDEF_OS_ADROID_H -#define BOOST_PREDEF_OS_ADROID_H +#ifndef BOOST_PREDEF_OS_ANDROID_H +#define BOOST_PREDEF_OS_ANDROID_H #include #include diff --git a/3rdparty/boost/boost/predef/os/bsd/free.h b/3rdparty/boost/boost/predef/os/bsd/free.h index 248011ae7a..81c002109d 100644 --- a/3rdparty/boost/boost/predef/os/bsd/free.h +++ b/3rdparty/boost/boost/predef/os/bsd/free.h @@ -34,13 +34,20 @@ http://www.boost.org/LICENSE_1_0.txt) # define BOOST_OS_BSD_AVAILABLE # endif # undef BOOST_OS_BSD_FREE +# include # if defined(__FreeBSD_version) -# if __FreeBSD_version < 500000 +# if __FreeBSD_version == 491000 # define BOOST_OS_BSD_FREE \ - BOOST_PREDEF_MAKE_10_VRP000(__FreeBSD_version) + BOOST_VERSION_NUMBER(4, 10, 0) +# elif __FreeBSD_version == 492000 +# define BOOST_OS_BSD_FREE \ + BOOST_VERSION_NUMBER(4, 11, 0) +# elif __FreeBSD_version < 500000 +# define BOOST_OS_BSD_FREE \ + BOOST_PREDEF_MAKE_10_VRPPPP(__FreeBSD_version) # else # define BOOST_OS_BSD_FREE \ - BOOST_PREDEF_MAKE_10_VRR000(__FreeBSD_version) + BOOST_PREDEF_MAKE_10_VVRRPPP(__FreeBSD_version) # endif # else # define BOOST_OS_BSD_FREE BOOST_VERSION_NUMBER_AVAILABLE diff --git a/3rdparty/boost/boost/predef/os/bsd/open.h b/3rdparty/boost/boost/predef/os/bsd/open.h index 423103ac5c..f6ccd24a9b 100644 --- a/3rdparty/boost/boost/predef/os/bsd/open.h +++ b/3rdparty/boost/boost/predef/os/bsd/open.h @@ -50,6 +50,26 @@ http://www.boost.org/LICENSE_1_0.txt) [[`OpenBSD4_7`] [4.7.0]] [[`OpenBSD4_8`] [4.8.0]] [[`OpenBSD4_9`] [4.9.0]] + [[`OpenBSD5_0`] [5.0.0]] + [[`OpenBSD5_1`] [5.1.0]] + [[`OpenBSD5_2`] [5.2.0]] + [[`OpenBSD5_3`] [5.3.0]] + [[`OpenBSD5_4`] [5.4.0]] + [[`OpenBSD5_5`] [5.5.0]] + [[`OpenBSD5_6`] [5.6.0]] + [[`OpenBSD5_7`] [5.7.0]] + [[`OpenBSD5_8`] [5.8.0]] + [[`OpenBSD5_9`] [5.9.0]] + [[`OpenBSD6_0`] [6.0.0]] + [[`OpenBSD6_1`] [6.1.0]] + [[`OpenBSD6_2`] [6.2.0]] + [[`OpenBSD6_3`] [6.3.0]] + [[`OpenBSD6_4`] [6.4.0]] + [[`OpenBSD6_5`] [6.5.0]] + [[`OpenBSD6_6`] [6.6.0]] + [[`OpenBSD6_7`] [6.7.0]] + [[`OpenBSD6_8`] [6.8.0]] + [[`OpenBSD6_9`] [6.9.0]] ] */ @@ -153,6 +173,66 @@ http://www.boost.org/LICENSE_1_0.txt) # if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_9) # define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,9,0) # endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_0) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,0,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_1) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,1,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_2) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,2,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_3) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,3,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_4) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,4,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_5) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,5,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_6) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,6,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_7) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,7,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_8) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,8,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD5_9) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(5,9,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_0) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,0,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_1) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,1,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_2) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,2,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_3) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,3,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_4) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,4,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_5) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,5,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_6) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,6,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_7) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,7,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_8) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,8,0) +# endif +# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD6_9) +# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(6,9,0) +# endif # if !defined(BOOST_OS_BSD_OPEN) # define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER_AVAILABLE # endif diff --git a/3rdparty/boost/boost/predef/other/endian.h b/3rdparty/boost/boost/predef/other/endian.h index 6d1f43ff4d..b42da53803 100644 --- a/3rdparty/boost/boost/predef/other/endian.h +++ b/3rdparty/boost/boost/predef/other/endian.h @@ -148,8 +148,7 @@ information and acquired knowledge: # undef BOOST_ENDIAN_BIG_BYTE # define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE # endif -# if BOOST_ARCH_AMD64 || \ - BOOST_ARCH_IA64 || \ +# if BOOST_ARCH_IA64 || \ BOOST_ARCH_X86 || \ BOOST_ARCH_BLACKFIN # undef BOOST_ENDIAN_LITTLE_BYTE diff --git a/3rdparty/boost/boost/predef/platform.h b/3rdparty/boost/boost/predef/platform.h index 7da697e63d..6c366d595c 100644 --- a/3rdparty/boost/boost/predef/platform.h +++ b/3rdparty/boost/boost/predef/platform.h @@ -11,11 +11,17 @@ http://www.boost.org/LICENSE_1_0.txt) #define BOOST_PREDEF_PLATFORM_H #endif +#include #include +#include +#include +#include #include -#include #include -#include +#include +#include +#include +#include // deprecated #include /*#include */ diff --git a/3rdparty/boost/boost/predef/platform/cloudabi.h b/3rdparty/boost/boost/predef/platform/cloudabi.h new file mode 100644 index 0000000000..c44f689454 --- /dev/null +++ b/3rdparty/boost/boost/predef/platform/cloudabi.h @@ -0,0 +1,43 @@ +/* + Copyright 2017 James E. King, III + 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_PREDEF_PLAT_CLOUDABI_H +#define BOOST_PREDEF_PLAT_CLOUDABI_H + +#include +#include + +/*` +[heading `BOOST_PLAT_CLOUDABI`] + +[@https://github.com/NuxiNL/cloudabi CloudABI] platform. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__CloudABI__`] [__predef_detection__]] + ] + */ + +#define BOOST_PLAT_CLOUDABI BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__CloudABI__) +# undef BOOST_PLAT_CLOUDABI +# define BOOST_PLAT_CLOUDABI BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_PLAT_CLOUDABI +# define BOOST_PLAT_CLOUDABI_AVAILABLE +# include +#endif + +#define BOOST_PLAT_CLOUDABI_NAME "CloudABI" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_CLOUDABI,BOOST_PLAT_CLOUDABI_NAME) diff --git a/3rdparty/boost/boost/predef/platform/mingw.h b/3rdparty/boost/boost/predef/platform/mingw.h index 5a1334b47c..c52827d7d8 100644 --- a/3rdparty/boost/boost/predef/platform/mingw.h +++ b/3rdparty/boost/boost/predef/platform/mingw.h @@ -14,7 +14,7 @@ http://www.boost.org/LICENSE_1_0.txt) /*` [heading `BOOST_PLAT_MINGW`] -[@http://en.wikipedia.org/wiki/MinGW MinGW] platform. +[@http://en.wikipedia.org/wiki/MinGW MinGW] platform, either variety. Version number available as major, minor, and patch. [table @@ -56,7 +56,7 @@ Version number available as major, minor, and patch. # include #endif -#define BOOST_PLAT_MINGW_NAME "MinGW" +#define BOOST_PLAT_MINGW_NAME "MinGW (any variety)" #endif diff --git a/3rdparty/boost/boost/predef/platform/mingw32.h b/3rdparty/boost/boost/predef/platform/mingw32.h new file mode 100644 index 0000000000..ff90038b4c --- /dev/null +++ b/3rdparty/boost/boost/predef/platform/mingw32.h @@ -0,0 +1,63 @@ +/* +Copyright Rene Rivera 2008-2015 +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_PREDEF_PLAT_MINGW32_H +#define BOOST_PREDEF_PLAT_MINGW32_H + +#include +#include + +/*` +[heading `BOOST_PLAT_MINGW32`] + +[@http://www.mingw.org/ MinGW] platform. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__MINGW32__`] [__predef_detection__]] + + [[`__MINGW32_VERSION_MAJOR`, `__MINGW32_VERSION_MINOR`] [V.R.0]] + ] + */ + +#define BOOST_PLAT_MINGW32 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__MINGW32__) +# include <_mingw.h> +# if !defined(BOOST_PLAT_MINGW32_DETECTION) && (defined(__MINGW32_VERSION_MAJOR) && defined(__MINGW32_VERSION_MINOR)) +# define BOOST_PLAT_MINGW32_DETECTION \ + BOOST_VERSION_NUMBER(__MINGW32_VERSION_MAJOR,__MINGW32_VERSION_MINOR,0) +# endif +# if !defined(BOOST_PLAT_MINGW32_DETECTION) +# define BOOST_PLAT_MINGW32_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_PLAT_MINGW32_DETECTION +# define BOOST_PLAT_MINGW32_AVAILABLE +# if defined(BOOST_PREDEF_DETAIL_PLAT_DETECTED) +# define BOOST_PLAT_MINGW32_EMULATED BOOST_PLAT_MINGW32_DETECTION +# else +# undef BOOST_PLAT_MINGW32 +# define BOOST_PLAT_MINGW32 BOOST_PLAT_MINGW32_DETECTION +# endif +# include +#endif + +#define BOOST_PLAT_MINGW32_NAME "MinGW" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_MINGW32,BOOST_PLAT_MINGW32_NAME) + +#ifdef BOOST_PLAT_MINGW32_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_MINGW32_EMULATED,BOOST_PLAT_MINGW32_NAME) +#endif diff --git a/3rdparty/boost/boost/predef/platform/mingw64.h b/3rdparty/boost/boost/predef/platform/mingw64.h new file mode 100644 index 0000000000..a35dd3e016 --- /dev/null +++ b/3rdparty/boost/boost/predef/platform/mingw64.h @@ -0,0 +1,63 @@ +/* +Copyright Rene Rivera 2008-2015 +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_PREDEF_PLAT_MINGW64_H +#define BOOST_PREDEF_PLAT_MINGW64_H + +#include +#include + +/*` +[heading `BOOST_PLAT_MINGW64`] + +[@https://mingw-w64.org/ MinGW-w64] platform. +Version number available as major, minor, and patch. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__MINGW64__`] [__predef_detection__]] + + [[`__MINGW64_VERSION_MAJOR`, `__MINGW64_VERSION_MINOR`] [V.R.0]] + ] + */ + +#define BOOST_PLAT_MINGW64 BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if defined(__MINGW64__) +# include <_mingw.h> +# if !defined(BOOST_PLAT_MINGW64_DETECTION) && (defined(__MINGW64_VERSION_MAJOR) && defined(__MINGW64_VERSION_MINOR)) +# define BOOST_PLAT_MINGW64_DETECTION \ + BOOST_VERSION_NUMBER(__MINGW64_VERSION_MAJOR,__MINGW64_VERSION_MINOR,0) +# endif +# if !defined(BOOST_PLAT_MINGW64_DETECTION) +# define BOOST_PLAT_MINGW64_DETECTION BOOST_VERSION_NUMBER_AVAILABLE +# endif +#endif + +#ifdef BOOST_PLAT_MINGW64_DETECTION +# define BOOST_PLAT_MINGW64_AVAILABLE +# if defined(BOOST_PREDEF_DETAIL_PLAT_DETECTED) +# define BOOST_PLAT_MINGW64_EMULATED BOOST_PLAT_MINGW64_DETECTION +# else +# undef BOOST_PLAT_MINGW64 +# define BOOST_PLAT_MINGW64 BOOST_PLAT_MINGW64_DETECTION +# endif +# include +#endif + +#define BOOST_PLAT_MINGW64_NAME "MinGW-w64" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_MINGW64,BOOST_PLAT_MINGW64_NAME) + +#ifdef BOOST_PLAT_MINGW64_EMULATED +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_MINGW64_EMULATED,BOOST_PLAT_MINGW64_NAME) +#endif diff --git a/3rdparty/boost/boost/predef/platform/windows_desktop.h b/3rdparty/boost/boost/predef/platform/windows_desktop.h index 62719b4299..afb39079a6 100644 --- a/3rdparty/boost/boost/predef/platform/windows_desktop.h +++ b/3rdparty/boost/boost/predef/platform/windows_desktop.h @@ -9,25 +9,31 @@ http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PREDEF_PLAT_WINDOWS_DESKTOP_H #define BOOST_PREDEF_PLAT_WINDOWS_DESKTOP_H -#include #include #include +#include +#include /*` [heading `BOOST_PLAT_WINDOWS_DESKTOP`] +[@https://docs.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide UWP] +for Windows Desktop development. Also available if the Platform SDK is too +old to support UWP. + [table [[__predef_symbol__] [__predef_version__]] - [[`!WINAPI_FAMILY`] [__predef_detection__]] [[`WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP`] [__predef_detection__]] + [[`!BOOST_PLAT_WINDOWS_UWP`] [__predef_detection__]] ] */ #define BOOST_PLAT_WINDOWS_DESKTOP BOOST_VERSION_NUMBER_NOT_AVAILABLE #if BOOST_OS_WINDOWS && \ - ( !defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) ) + ((defined(WINAPI_FAMILY_DESKTOP_APP) && WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) || \ + !BOOST_PLAT_WINDOWS_UWP) # undef BOOST_PLAT_WINDOWS_DESKTOP # define BOOST_PLAT_WINDOWS_DESKTOP BOOST_VERSION_NUMBER_AVAILABLE #endif diff --git a/3rdparty/boost/boost/predef/platform/windows_phone.h b/3rdparty/boost/boost/predef/platform/windows_phone.h index df583adc02..0ebc76d276 100644 --- a/3rdparty/boost/boost/predef/platform/windows_phone.h +++ b/3rdparty/boost/boost/predef/platform/windows_phone.h @@ -9,13 +9,17 @@ http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PREDEF_PLAT_WINDOWS_PHONE_H #define BOOST_PREDEF_PLAT_WINDOWS_PHONE_H -#include #include #include +#include +#include /*` [heading `BOOST_PLAT_WINDOWS_PHONE`] +[@https://docs.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide UWP] +for Windows Phone development. + [table [[__predef_symbol__] [__predef_version__]] @@ -25,7 +29,8 @@ http://www.boost.org/LICENSE_1_0.txt) #define BOOST_PLAT_WINDOWS_PHONE BOOST_VERSION_NUMBER_NOT_AVAILABLE -#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP +#if BOOST_OS_WINDOWS && \ + defined(WINAPI_FAMILY_PHONE_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP # undef BOOST_PLAT_WINDOWS_PHONE # define BOOST_PLAT_WINDOWS_PHONE BOOST_VERSION_NUMBER_AVAILABLE #endif diff --git a/3rdparty/boost/boost/predef/platform/windows_runtime.h b/3rdparty/boost/boost/predef/platform/windows_runtime.h index 03be5140e9..e7978d7525 100644 --- a/3rdparty/boost/boost/predef/platform/windows_runtime.h +++ b/3rdparty/boost/boost/predef/platform/windows_runtime.h @@ -9,25 +9,33 @@ http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PREDEF_PLAT_WINDOWS_RUNTIME_H #define BOOST_PREDEF_PLAT_WINDOWS_RUNTIME_H -#include #include #include +#include +#include +#include /*` [heading `BOOST_PLAT_WINDOWS_RUNTIME`] +Deprecated. + +[@https://docs.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide UWP] +for Windows Phone or Store development. This does not align to the existing development model for +UWP and is deprecated. Use one of the other `BOOST_PLAT_WINDOWS_*`definitions instead. + [table [[__predef_symbol__] [__predef_version__]] - [[`WINAPI_FAMILY == WINAPI_FAMILY_APP`] [__predef_detection__]] - [[`WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP`] [__predef_detection__]] + [[`BOOST_PLAT_WINDOWS_PHONE`] [__predef_detection__]] + [[`BOOST_PLAT_WINDOWS_STORE`] [__predef_detection__]] ] */ #define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_NOT_AVAILABLE -#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && \ - ( WINAPI_FAMILY == WINAPI_FAMILY_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP ) +#if BOOST_OS_WINDOWS && \ + (BOOST_PLAT_WINDOWS_STORE || BOOST_PLAT_WINDOWS_PHONE) # undef BOOST_PLAT_WINDOWS_RUNTIME # define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_AVAILABLE #endif diff --git a/3rdparty/boost/boost/predef/platform/windows_server.h b/3rdparty/boost/boost/predef/platform/windows_server.h new file mode 100644 index 0000000000..7bd629da34 --- /dev/null +++ b/3rdparty/boost/boost/predef/platform/windows_server.h @@ -0,0 +1,47 @@ +/* +Copyright James E. King III, 2017 +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_PREDEF_PLAT_WINDOWS_SERVER_H +#define BOOST_PREDEF_PLAT_WINDOWS_SERVER_H + +#include +#include +#include +#include + +/*` +[heading `BOOST_PLAT_WINDOWS_SERVER`] + +[@https://docs.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide UWP] +for Windows Server development. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`WINAPI_FAMILY == WINAPI_FAMILY_SERVER`] [__predef_detection__]] + ] + */ + +#define BOOST_PLAT_WINDOWS_SERVER BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if BOOST_OS_WINDOWS && \ + defined(WINAPI_FAMILY_SERVER) && WINAPI_FAMILY == WINAPI_FAMILY_SERVER +# undef BOOST_PLAT_WINDOWS_SERVER +# define BOOST_PLAT_WINDOWS_SERVER BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_PLAT_WINDOWS_SERVER +# define BOOST_PLAT_WINDOWS_SERVER_AVAILABLE +# include +#endif + +#define BOOST_PLAT_WINDOWS_SERVER_NAME "Windows Server" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_SERVER,BOOST_PLAT_WINDOWS_SERVER_NAME) diff --git a/3rdparty/boost/boost/predef/platform/windows_store.h b/3rdparty/boost/boost/predef/platform/windows_store.h index a34968b3dd..3a3fd8e982 100644 --- a/3rdparty/boost/boost/predef/platform/windows_store.h +++ b/3rdparty/boost/boost/predef/platform/windows_store.h @@ -9,23 +9,30 @@ http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PREDEF_PLAT_WINDOWS_STORE_H #define BOOST_PREDEF_PLAT_WINDOWS_STORE_H -#include #include #include +#include +#include /*` [heading `BOOST_PLAT_WINDOWS_STORE`] +[@https://docs.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide UWP] +for Windows Store development. + [table [[__predef_symbol__] [__predef_version__]] - [[`WINAPI_FAMILY == WINAPI_FAMILY_APP`] [__predef_detection__]] - ] + [[`WINAPI_FAMILY == WINAPI_FAMILY_PC_APP`] [__predef_detection__]] + [[`WINAPI_FAMILY == WINAPI_FAMILY_APP` (deprecated)] [__predef_detection__]] +] */ #define BOOST_PLAT_WINDOWS_STORE BOOST_VERSION_NUMBER_NOT_AVAILABLE -#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_APP +#if BOOST_OS_WINDOWS && \ + ((defined(WINAPI_FAMILY_PC_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PC_APP) || \ + (defined(WINAPI_FAMILY_APP) && WINAPI_FAMILY == WINAPI_FAMILY_APP)) # undef BOOST_PLAT_WINDOWS_STORE # define BOOST_PLAT_WINDOWS_STORE BOOST_VERSION_NUMBER_AVAILABLE #endif diff --git a/3rdparty/boost/boost/predef/platform/windows_system.h b/3rdparty/boost/boost/predef/platform/windows_system.h new file mode 100644 index 0000000000..92f424fe7f --- /dev/null +++ b/3rdparty/boost/boost/predef/platform/windows_system.h @@ -0,0 +1,47 @@ +/* +Copyright James E. King III, 2017 +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_PREDEF_PLAT_WINDOWS_SYSTEM_H +#define BOOST_PREDEF_PLAT_WINDOWS_SYSTEM_H + +#include +#include +#include +#include + +/*` +[heading `BOOST_PLAT_WINDOWS_SYSTEM`] + +[@https://docs.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide UWP] +for Windows System development. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`WINAPI_FAMILY == WINAPI_FAMILY_SYSTEM`] [__predef_detection__]] + ] + */ + +#define BOOST_PLAT_WINDOWS_SYSTEM BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if BOOST_OS_WINDOWS && \ + defined(WINAPI_FAMILY_SYSTEM) && WINAPI_FAMILY == WINAPI_FAMILY_SYSTEM +# undef BOOST_PLAT_WINDOWS_SYSTEM +# define BOOST_PLAT_WINDOWS_SYSTEM BOOST_VERSION_NUMBER_AVAILABLE +#endif + +#if BOOST_PLAT_WINDOWS_SYSTEM +# define BOOST_PLAT_WINDOWS_SYSTEM_AVAILABLE +# include +#endif + +#define BOOST_PLAT_WINDOWS_SYSTEM_NAME "Windows Drivers and Tools" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_SYSTEM,BOOST_PLAT_WINDOWS_SYSTEM_NAME) diff --git a/3rdparty/boost/boost/predef/platform/windows_uwp.h b/3rdparty/boost/boost/predef/platform/windows_uwp.h new file mode 100644 index 0000000000..e4c6647f41 --- /dev/null +++ b/3rdparty/boost/boost/predef/platform/windows_uwp.h @@ -0,0 +1,60 @@ +/* +Copyright James E. King III, 2017 +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_PREDEF_PLAT_WINDOWS_UWP_H +#define BOOST_PREDEF_PLAT_WINDOWS_UWP_H + +#include +#include +#include + +/*` +[heading `BOOST_PLAT_WINDOWS_UWP`] + +[@http://docs.microsoft.com/windows/uwp/ Universal Windows Platform] +is available if the current development environment is capable of targeting +UWP development. + +[table + [[__predef_symbol__] [__predef_version__]] + + [[`__MINGW64_VERSION_MAJOR` from `_mingw.h`] [`>= 3`]] + [[`VER_PRODUCTBUILD` from `ntverp.h`] [`>= 9200`]] +] +*/ + +#define BOOST_PLAT_WINDOWS_UWP BOOST_VERSION_NUMBER_NOT_AVAILABLE +#define BOOST_PLAT_WINDOWS_SDK_VERSION BOOST_VERSION_NUMBER_NOT_AVAILABLE + +#if BOOST_OS_WINDOWS +// MinGW (32-bit) has no ntverp.h header +#if !defined(__MINGW32__) +# include +# undef BOOST_PLAT_WINDOWS_SDK_VERSION +# define BOOST_PLAT_WINDOWS_SDK_VERSION BOOST_VERSION_NUMBER(0, 0, VER_PRODUCTBUILD) +#endif + +// 9200 is Windows SDK 8.0 from ntverp.h which introduced family support +#if ((BOOST_PLAT_WINDOWS_SDK_VERSION >= BOOST_VERSION_NUMBER(0, 0, 9200)) || \ + (defined(__MINGW64__) && __MINGW64_VERSION_MAJOR >= 3)) +# undef BOOST_PLAT_WINDOWS_UWP +# define BOOST_PLAT_WINDOWS_UWP BOOST_VERSION_NUMBER_AVAILABLE +#endif +#endif + +#if BOOST_PLAT_WINDOWS_UWP +# define BOOST_PLAT_WINDOWS_UWP_AVAILABLE +# include +# include // Windows SDK +#endif + +#define BOOST_PLAT_WINDOWS_UWP_NAME "Universal Windows Platform" + +#endif + +#include +BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_UWP, BOOST_PLAT_WINDOWS_UWP_NAME) diff --git a/3rdparty/boost/boost/predef/version.h b/3rdparty/boost/boost/predef/version.h index e03469f68d..960292fec6 100644 --- a/3rdparty/boost/boost/predef/version.h +++ b/3rdparty/boost/boost/predef/version.h @@ -10,6 +10,6 @@ http://www.boost.org/LICENSE_1_0.txt) #include -#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,6,0) +#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,8,0) #endif diff --git a/3rdparty/boost/boost/preprocessor/config/config.hpp b/3rdparty/boost/boost/preprocessor/config/config.hpp index 28dcdd4642..cdb044c87b 100644 --- a/3rdparty/boost/boost/preprocessor/config/config.hpp +++ b/3rdparty/boost/boost/preprocessor/config/config.hpp @@ -71,8 +71,10 @@ # 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 __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 __IBMCPP__ || defined __PGI +# if defined __GCCXML__ || 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 # define BOOST_PP_VARIADICS 0 +# elif defined(__CUDACC__) +# define BOOST_PP_VARIADICS 1 # elif defined(_MSC_VER) && defined(__clang__) # define BOOST_PP_VARIADICS 1 # /* VC++ (C/C++) and Intel C++ Compiler >= 17.0 with MSVC */ diff --git a/3rdparty/boost/boost/range/begin.hpp b/3rdparty/boost/boost/range/begin.hpp index ba5a73b92d..0d7d3db1c8 100644 --- a/3rdparty/boost/boost/range/begin.hpp +++ b/3rdparty/boost/boost/range/begin.hpp @@ -36,7 +36,7 @@ namespace range_detail ////////////////////////////////////////////////////////////////////// template< typename C > - inline BOOST_DEDUCED_TYPENAME range_iterator::type + BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator::type range_begin( C& c ) { // @@ -52,13 +52,13 @@ namespace range_detail ////////////////////////////////////////////////////////////////////// template< typename Iterator > - inline Iterator range_begin( const std::pair& p ) + BOOST_CONSTEXPR inline Iterator range_begin( const std::pair& p ) { return p.first; } template< typename Iterator > - inline Iterator range_begin( std::pair& p ) + BOOST_CONSTEXPR inline Iterator range_begin( std::pair& p ) { return p.first; } @@ -71,13 +71,13 @@ namespace range_detail // May this be discarded? Or is it needed for bad compilers? // template< typename T, std::size_t sz > - inline const T* range_begin( const T (&a)[sz] ) + BOOST_CONSTEXPR inline const T* range_begin( const T (&a)[sz] ) BOOST_NOEXCEPT { return a; } template< typename T, std::size_t sz > - inline T* range_begin( T (&a)[sz] ) + BOOST_CONSTEXPR inline T* range_begin( T (&a)[sz] ) BOOST_NOEXCEPT { return a; } @@ -94,7 +94,7 @@ namespace range_adl_barrier { template< class T > -inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( T& r ) +BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( T& r ) { #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; @@ -103,7 +103,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( T& r ) } template< class T > -inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( const T& r ) +BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( const T& r ) { #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; diff --git a/3rdparty/boost/boost/range/concepts.hpp b/3rdparty/boost/boost/range/concepts.hpp index 3e612a35f9..f6f9f41af4 100644 --- a/3rdparty/boost/boost/range/concepts.hpp +++ b/3rdparty/boost/boost/range/concepts.hpp @@ -25,6 +25,8 @@ #include #include +#include + /*! * \file * \brief Concept checks for the Boost Range library. @@ -164,10 +166,10 @@ namespace boost { // work (void)(i++); - BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::reference r1(*i); + BOOST_DEDUCED_TYPENAME std::iterator_traits::reference r1(*i); boost::ignore_unused_variable_warning(r1); - BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::reference r2(*(++i)); + BOOST_DEDUCED_TYPENAME std::iterator_traits::reference r2(*(++i)); boost::ignore_unused_variable_warning(r2); } private: @@ -181,7 +183,7 @@ namespace boost { , DefaultConstructible { #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT - typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::difference_type difference_type; + typedef BOOST_DEDUCED_TYPENAME std::iterator_traits::difference_type difference_type; BOOST_MPL_ASSERT((is_integral)); BOOST_MPL_ASSERT_RELATION(std::numeric_limits::is_signed, ==, true); @@ -200,7 +202,7 @@ namespace boost { // is convertible to reference. Iterator i2(i++); boost::ignore_unused_variable_warning(i2); - BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits::reference r(*(i++)); + BOOST_DEDUCED_TYPENAME std::iterator_traits::reference r(*(i++)); boost::ignore_unused_variable_warning(r); } private: @@ -250,7 +252,7 @@ namespace boost { n = i - j; } private: - BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n; + BOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept::difference_type n; Iterator i; Iterator j; #endif diff --git a/3rdparty/boost/boost/range/detail/begin.hpp b/3rdparty/boost/boost/range/detail/begin.hpp index 1d9390ff85..efadaa6b8c 100644 --- a/3rdparty/boost/boost/range/detail/begin.hpp +++ b/3rdparty/boost/boost/range/detail/begin.hpp @@ -32,7 +32,7 @@ namespace boost struct range_begin { template< typename C > - static BOOST_RANGE_DEDUCED_TYPENAME range_iterator::type fun( C& c ) + BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_iterator::type fun( C& c ) { return c.begin(); }; @@ -46,7 +46,7 @@ namespace boost struct range_begin { template< typename P > - static BOOST_RANGE_DEDUCED_TYPENAME range_iterator

::type fun( const P& p ) + BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_iterator

::type fun( const P& p ) { return p.first; } @@ -60,7 +60,7 @@ namespace boost struct range_begin { template - static BOOST_RANGE_DEDUCED_TYPENAME range_value::type* fun(T& t) + BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_value::type* fun(T& t) { return t; } @@ -71,7 +71,7 @@ namespace boost namespace range_adl_barrier { template< typename C > - inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator::type + BOOST_CONSTEXPR inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator::type begin( C& c ) { return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range::type >::fun( c ); diff --git a/3rdparty/boost/boost/range/detail/common.hpp b/3rdparty/boost/boost/range/detail/common.hpp index 00b665bef8..2cbc55411d 100644 --- a/3rdparty/boost/boost/range/detail/common.hpp +++ b/3rdparty/boost/boost/range/detail/common.hpp @@ -18,10 +18,8 @@ #include #include #include -#include #include #include -#include #include ////////////////////////////////////////////////////////////////////////////// @@ -71,7 +69,7 @@ namespace boost BOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) ); BOOST_STATIC_CONSTANT( bool, is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) ); BOOST_STATIC_CONSTANT( bool, is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) ); - BOOST_STATIC_CONSTANT( bool, is_string_ = (boost::mpl::or_, boost::mpl::bool_ >::value )); + BOOST_STATIC_CONSTANT( bool, is_string_ = (is_const_char_ptr_ || is_const_wchar_t_ptr_)); BOOST_STATIC_CONSTANT( bool, is_array_ = boost::is_array::value ); }; diff --git a/3rdparty/boost/boost/range/detail/end.hpp b/3rdparty/boost/boost/range/detail/end.hpp index f2f71780a7..76229216a5 100644 --- a/3rdparty/boost/boost/range/detail/end.hpp +++ b/3rdparty/boost/boost/range/detail/end.hpp @@ -33,7 +33,7 @@ namespace boost struct range_end { template< typename C > - static BOOST_RANGE_DEDUCED_TYPENAME range_iterator::type + BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_iterator::type fun( C& c ) { return c.end(); @@ -48,7 +48,7 @@ namespace boost struct range_end { template< typename P > - static BOOST_RANGE_DEDUCED_TYPENAME range_iterator

::type + BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_iterator

::type fun( const P& p ) { return p.second; @@ -63,7 +63,7 @@ namespace boost struct range_end { template - static BOOST_RANGE_DEDUCED_TYPENAME remove_extent::type* fun(T& t) + BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME remove_extent::type* fun(T& t) { return t + remove_extent::size; } @@ -74,7 +74,7 @@ namespace boost namespace range_adl_barrier { template< typename C > - inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator::type + BOOST_CONSTEXPR inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator::type end( C& c ) { return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range::type >::fun( c ); diff --git a/3rdparty/boost/boost/range/detail/implementation_help.hpp b/3rdparty/boost/boost/range/detail/implementation_help.hpp index f35953f349..59a3ade837 100644 --- a/3rdparty/boost/boost/range/detail/implementation_help.hpp +++ b/3rdparty/boost/boost/range/detail/implementation_help.hpp @@ -60,13 +60,13 @@ namespace boost } template< class T, std::size_t sz > - inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] ) + BOOST_CONSTEXPR inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] ) BOOST_NOEXCEPT { return boost_range_array + sz; } template< class T, std::size_t sz > - inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] ) + BOOST_CONSTEXPR inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] ) BOOST_NOEXCEPT { return boost_range_array + sz; } diff --git a/3rdparty/boost/boost/range/distance.hpp b/3rdparty/boost/boost/range/distance.hpp index 075f2d1fb9..8dcf05bc68 100644 --- a/3rdparty/boost/boost/range/distance.hpp +++ b/3rdparty/boost/boost/range/distance.hpp @@ -15,18 +15,19 @@ # pragma once #endif +#include #include #include #include -namespace boost +namespace boost { template< class T > - inline BOOST_DEDUCED_TYPENAME range_difference::type + inline BOOST_CXX14_CONSTEXPR BOOST_DEDUCED_TYPENAME range_difference::type distance( const T& r ) { - return std::distance( boost::begin( r ), boost::end( r ) ); + return boost::distance( boost::begin( r ), boost::end( r ) ); } } // namespace 'boost' diff --git a/3rdparty/boost/boost/range/end.hpp b/3rdparty/boost/boost/range/end.hpp index f2a3337e34..588495cee5 100644 --- a/3rdparty/boost/boost/range/end.hpp +++ b/3rdparty/boost/boost/range/end.hpp @@ -37,7 +37,7 @@ namespace range_detail // primary template ////////////////////////////////////////////////////////////////////// template< typename C > - inline BOOST_DEDUCED_TYPENAME range_iterator::type + BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator::type range_end( C& c ) { // @@ -53,13 +53,13 @@ namespace range_detail ////////////////////////////////////////////////////////////////////// template< typename Iterator > - inline Iterator range_end( const std::pair& p ) + BOOST_CONSTEXPR inline Iterator range_end( const std::pair& p ) { return p.second; } template< typename Iterator > - inline Iterator range_end( std::pair& p ) + BOOST_CONSTEXPR inline Iterator range_end( std::pair& p ) { return p.second; } @@ -69,13 +69,13 @@ namespace range_detail ////////////////////////////////////////////////////////////////////// template< typename T, std::size_t sz > - inline const T* range_end( const T (&a)[sz] ) + BOOST_CONSTEXPR inline const T* range_end( const T (&a)[sz] ) BOOST_NOEXCEPT { return range_detail::array_end( a ); } template< typename T, std::size_t sz > - inline T* range_end( T (&a)[sz] ) + BOOST_CONSTEXPR inline T* range_end( T (&a)[sz] ) BOOST_NOEXCEPT { return range_detail::array_end( a ); } @@ -88,7 +88,7 @@ namespace range_adl_barrier { template< class T > -inline BOOST_DEDUCED_TYPENAME range_iterator::type end( T& r ) +BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator::type end( T& r ) { #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; @@ -97,7 +97,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator::type end( T& r ) } template< class T > -inline BOOST_DEDUCED_TYPENAME range_iterator::type end( const T& r ) +BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator::type end( const T& r ) { #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; @@ -115,7 +115,7 @@ namespace boost namespace range_adl_barrier { template< class T > - inline BOOST_DEDUCED_TYPENAME range_iterator::type + BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator::type const_end( const T& r ) { return boost::range_adl_barrier::end( r ); diff --git a/3rdparty/boost/boost/range/has_range_iterator.hpp b/3rdparty/boost/boost/range/has_range_iterator.hpp index 9eb58b35d2..88d8664d16 100644 --- a/3rdparty/boost/boost/range/has_range_iterator.hpp +++ b/3rdparty/boost/boost/range/has_range_iterator.hpp @@ -37,9 +37,9 @@ namespace boost T, BOOST_DEDUCED_TYPENAME ::boost::enable_if< BOOST_DEDUCED_TYPENAME mpl::eval_if, - has_type::type> >, - has_type > + has_type > >::type >::type > @@ -57,7 +57,7 @@ namespace boost struct has_range_const_iterator_impl< T, BOOST_DEDUCED_TYPENAME ::boost::enable_if< - has_type > + has_type > >::type > : boost::mpl::true_ diff --git a/3rdparty/boost/boost/range/iterator_range_core.hpp b/3rdparty/boost/boost/range/iterator_range_core.hpp index a9e9fc0f13..7f2dc3f9c8 100644 --- a/3rdparty/boost/boost/range/iterator_range_core.hpp +++ b/3rdparty/boost/boost/range/iterator_range_core.hpp @@ -42,6 +42,7 @@ #include #include #include +#include #include #include #include diff --git a/3rdparty/boost/boost/regex/config.hpp b/3rdparty/boost/boost/regex/config.hpp index 589b1e3a4f..eb998110bf 100644 --- a/3rdparty/boost/boost/regex/config.hpp +++ b/3rdparty/boost/boost/regex/config.hpp @@ -163,7 +163,7 @@ # define BOOST_REGEX_NO_LIB #endif -#if defined(__GNUC__) && (defined(_WIN32) || defined(__CYGWIN__)) +#if defined(__GNUC__) && !defined(_MSC_VER) && (defined(_WIN32) || defined(__CYGWIN__)) /* gcc on win32 has problems if you include (sporadically generates bad code). */ # define BOOST_REGEX_NO_W32 diff --git a/3rdparty/boost/boost/regex/pending/object_cache.hpp b/3rdparty/boost/boost/regex/pending/object_cache.hpp index d47fbba9cd..c47862f0e6 100644 --- a/3rdparty/boost/boost/regex/pending/object_cache.hpp +++ b/3rdparty/boost/boost/regex/pending/object_cache.hpp @@ -19,12 +19,12 @@ #ifndef BOOST_REGEX_OBJECT_CACHE_HPP #define BOOST_REGEX_OBJECT_CACHE_HPP +#include +#include #include #include #include #include -#include -#include #ifdef BOOST_HAS_THREADS #include #endif diff --git a/3rdparty/boost/boost/regex/v4/basic_regex_creator.hpp b/3rdparty/boost/boost/regex/v4/basic_regex_creator.hpp index 132ff84f07..623e06f162 100644 --- a/3rdparty/boost/boost/regex/v4/basic_regex_creator.hpp +++ b/3rdparty/boost/boost/regex/v4/basic_regex_creator.hpp @@ -43,8 +43,8 @@ namespace BOOST_REGEX_DETAIL_NS{ template struct digraph : public std::pair { - digraph() : std::pair(0, 0){} - digraph(charT c1) : std::pair(c1, 0){} + digraph() : std::pair(charT(0), charT(0)){} + digraph(charT c1) : std::pair(c1, charT(0)){} digraph(charT c1, charT c2) : std::pair(c1, c2) {} digraph(const digraph& d) : std::pair(d.first, d.second){} diff --git a/3rdparty/boost/boost/regex/v4/basic_regex_parser.hpp b/3rdparty/boost/boost/regex/v4/basic_regex_parser.hpp index 4ab1670e1f..7c2852fa51 100644 --- a/3rdparty/boost/boost/regex/v4/basic_regex_parser.hpp +++ b/3rdparty/boost/boost/regex/v4/basic_regex_parser.hpp @@ -105,6 +105,7 @@ private: std::ptrdiff_t m_paren_start; // where the last seen ')' began (where repeats are inserted). std::ptrdiff_t m_alt_insert_point; // where to insert the next alternative bool m_has_case_change; // true if somewhere in the current block the case has changed + unsigned m_recursion_count; // How many times we've called parse_all. #if defined(BOOST_MSVC) && defined(_M_IX86) // This is an ugly warning suppression workaround (for warnings *inside* std::vector // that can not otherwise be suppressed)... @@ -120,7 +121,7 @@ private: template basic_regex_parser::basic_regex_parser(regex_data* data) - : basic_regex_creator(data), m_mark_count(0), m_mark_reset(-1), m_max_mark(0), m_paren_start(0), m_alt_insert_point(0), m_has_case_change(false) + : basic_regex_creator(data), m_mark_count(0), m_mark_reset(-1), m_max_mark(0), m_paren_start(0), m_alt_insert_point(0), m_has_case_change(false), m_recursion_count(0) { } @@ -245,11 +246,17 @@ void basic_regex_parser::fail(regex_constants::error_type error_c template bool basic_regex_parser::parse_all() { + if (++m_recursion_count > 400) + { + // exceeded internal limits + fail(boost::regex_constants::error_complexity, m_position - m_base, "Exceeded nested brace limit."); + } bool result = true; while(result && (m_position != m_end)) { result = (this->*m_parser_proc)(); } + --m_recursion_count; return result; } @@ -971,7 +978,13 @@ bool basic_regex_parser::parse_repeat(std::size_t low, std::size_ ) { // OK we have a perl or emacs regex, check for a '?': - if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question) + if ((this->flags() & (regbase::main_option_type | regbase::mod_x | regbase::no_perl_ex)) == regbase::mod_x) + { + // whitespace skip: + while ((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space)) + ++m_position; + } + if((m_position != m_end) && (this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question)) { greedy = false; ++m_position; @@ -1064,15 +1077,42 @@ bool basic_regex_parser::parse_repeat(std::size_t low, std::size_ // Check for illegal following quantifier, we have to do this here, because // the extra states we insert below circumvents our usual error checking :-( // - switch(this->m_traits.syntax_type(*m_position)) + bool contin = false; + do { - case regex_constants::syntax_star: - case regex_constants::syntax_plus: - case regex_constants::syntax_question: - case regex_constants::syntax_open_brace: - fail(regex_constants::error_badrepeat, m_position - m_base); - return false; - } + if ((this->flags() & (regbase::main_option_type | regbase::mod_x | regbase::no_perl_ex)) == regbase::mod_x) + { + // whitespace skip: + while ((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space)) + ++m_position; + } + if (m_position != m_end) + { + switch (this->m_traits.syntax_type(*m_position)) + { + case regex_constants::syntax_star: + case regex_constants::syntax_plus: + case regex_constants::syntax_question: + case regex_constants::syntax_open_brace: + fail(regex_constants::error_badrepeat, m_position - m_base); + return false; + case regex_constants::syntax_open_mark: + // Do we have a comment? If so we need to skip it here... + if ((m_position + 2 < m_end) && this->m_traits.syntax_type(*(m_position + 1)) == regex_constants::syntax_question + && this->m_traits.syntax_type(*(m_position + 2)) == regex_constants::syntax_hash) + { + while ((m_position != m_end) + && (this->m_traits.syntax_type(*m_position++) != regex_constants::syntax_close_mark)) { + } + contin = true; + } + else + contin = false; + } + } + else + contin = false; + } while (contin); } re_brace* pb = static_cast(this->insert_state(insert_point, syntax_element_startmark, sizeof(re_brace))); pb->index = -3; @@ -1991,7 +2031,7 @@ bool basic_regex_parser::parse_perl_extension() { while((m_position != m_end) && (this->m_traits.syntax_type(*m_position++) != regex_constants::syntax_close_mark)) - {} + {} return true; } // @@ -2070,6 +2110,11 @@ insert_recursion: fail(regex_constants::error_perl_extension, m_position - m_base, "An invalid or unterminated recursive sub-expression."); return false; } + if ((std::numeric_limits::max)() - m_mark_count < v) + { + fail(regex_constants::error_perl_extension, m_position - m_base, "An invalid or unterminated recursive sub-expression."); + return false; + } v += m_mark_count; goto insert_recursion; case regex_constants::syntax_dash: diff --git a/3rdparty/boost/boost/regex/v4/perl_matcher.hpp b/3rdparty/boost/boost/regex/v4/perl_matcher.hpp index 32517c62e7..a696e5d99b 100644 --- a/3rdparty/boost/boost/regex/v4/perl_matcher.hpp +++ b/3rdparty/boost/boost/regex/v4/perl_matcher.hpp @@ -122,7 +122,7 @@ inline int string_compare(const Seq& s, const C* p) { ++i; } - return (i == s.size()) ? -p[i] : s[i] - p[i]; + return (i == s.size()) ? -(int)p[i] : (int)s[i] - (int)p[i]; } # define STR_COMP(s,p) string_compare(s,p) @@ -379,6 +379,9 @@ public: : m_result(what), base(first), last(end), position(first), backstop(l_base), re(e), traits_inst(e.get_traits()), m_independent(false), next_count(&rep_obj), rep_obj(&next_count) +#ifdef BOOST_REGEX_NON_RECURSIVE + , m_recursions(0) +#endif { construct_init(e, f); } @@ -547,7 +550,7 @@ private: void push_repeater_count(int i, repeater_count** s); void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id); void push_non_greedy_repeat(const re_syntax_base* ps); - void push_recursion(int idx, const re_syntax_base* p, results_type* presults); + void push_recursion(int idx, const re_syntax_base* p, results_type* presults, results_type* presults2); void push_recursion_pop(); void push_case_change(bool); @@ -566,6 +569,8 @@ private: bool m_unwound_alt; // We are unwinding a commit - used by independent subs to determine whether to stop there or carry on unwinding: //bool m_unwind_commit; + // Recursion limit: + unsigned m_recursions; #endif // these operations aren't allowed, so are declared private, diff --git a/3rdparty/boost/boost/regex/v4/perl_matcher_common.hpp b/3rdparty/boost/boost/regex/v4/perl_matcher_common.hpp index 7974e74835..a0973da92a 100644 --- a/3rdparty/boost/boost/regex/v4/perl_matcher_common.hpp +++ b/3rdparty/boost/boost/regex/v4/perl_matcher_common.hpp @@ -113,6 +113,11 @@ void perl_matcher::estimate_max_state_count(std std::ptrdiff_t states = re.size(); if(states == 0) states = 1; + if ((std::numeric_limits::max)() / states < states) + { + max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits::max)() - 2); + return; + } states *= states; if((std::numeric_limits::max)() / dist < states) { @@ -772,7 +777,7 @@ inline bool perl_matcher::match_assert_backref( { // Have we recursed into subexpression "index"? // If index == 0 then check for any recursion at all, otherwise for recursion to -index-1. - int idx = -index-1; + int idx = -(index+1); if(idx >= 10000) { named_subexpressions::range_type r = re.get_data().equal_range(idx); diff --git a/3rdparty/boost/boost/regex/v4/perl_matcher_non_recursive.hpp b/3rdparty/boost/boost/regex/v4/perl_matcher_non_recursive.hpp index c12dea8e72..3d89749d02 100644 --- a/3rdparty/boost/boost/regex/v4/perl_matcher_non_recursive.hpp +++ b/3rdparty/boost/boost/regex/v4/perl_matcher_non_recursive.hpp @@ -130,11 +130,11 @@ struct saved_single_repeat : public saved_state template struct saved_recursion : public saved_state { - saved_recursion(int idx, const re_syntax_base* p, Results* pr) - : saved_state(14), recursion_id(idx), preturn_address(p), results(*pr) {} + saved_recursion(int idx, const re_syntax_base* p, Results* pr, Results* pr2) + : saved_state(14), recursion_id(idx), preturn_address(p), internal_results(*pr), prior_results(*pr2) {} int recursion_id; const re_syntax_base* preturn_address; - Results results; + Results internal_results, prior_results; }; struct saved_change_case : public saved_state @@ -143,6 +143,15 @@ struct saved_change_case : public saved_state saved_change_case(bool c) : saved_state(18), icase(c) {} }; +struct incrementer +{ + incrementer(unsigned* pu) : m_pu(pu) { ++*m_pu; } + ~incrementer() { --*m_pu; } + bool operator > (unsigned i) { return *m_pu > i; } +private: + unsigned* m_pu; +}; + template bool perl_matcher::match_all_states() { @@ -187,7 +196,9 @@ bool perl_matcher::match_all_states() &perl_matcher::match_commit, &perl_matcher::match_then, }; - + incrementer inc(&m_recursions); + if(inc > 80) + raise_error(traits_inst, regex_constants::error_complexity); push_recursion_stopper(); do{ while(pstate) @@ -354,7 +365,7 @@ inline void perl_matcher::push_single_repeat(st } template -inline void perl_matcher::push_recursion(int idx, const re_syntax_base* p, results_type* presults) +inline void perl_matcher::push_recursion(int idx, const re_syntax_base* p, results_type* presults, results_type* presults2) { saved_recursion* pmp = static_cast*>(m_backup_state); --pmp; @@ -364,7 +375,7 @@ inline void perl_matcher::push_recursion(int id pmp = static_cast*>(m_backup_state); --pmp; } - (void) new (pmp)saved_recursion(idx, p, presults); + (void) new (pmp)saved_recursion(idx, p, presults, presults2); m_backup_state = pmp; } @@ -688,7 +699,7 @@ bool perl_matcher::match_rep() template bool perl_matcher::match_dot_repeat_slow() { - unsigned count = 0; + std::size_t count = 0; const re_repeat* rep = static_cast(pstate); re_syntax_base* psingle = rep->next.p; // match compulsary repeats first: @@ -740,7 +751,7 @@ bool perl_matcher::match_dot_repeat_fast() const re_repeat* rep = static_cast(pstate); bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent); - unsigned count = static_cast((std::min)(static_cast(::boost::BOOST_REGEX_DETAIL_NS::distance(position, last)), static_cast(greedy ? rep->max : rep->min))); + std::size_t count = static_cast((std::min)(static_cast(::boost::BOOST_REGEX_DETAIL_NS::distance(position, last)), greedy ? rep->max : rep->min)); if(rep->min > count) { position = last; @@ -1052,7 +1063,7 @@ bool perl_matcher::match_endmark() { pstate = recursion_stack.back().preturn_address; *m_presult = recursion_stack.back().results; - push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, &recursion_stack.back().results); + push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, m_presult, &recursion_stack.back().results); recursion_stack.pop_back(); push_repeater_count(-(2 + index), &next_count); } @@ -1075,8 +1086,8 @@ bool perl_matcher::match_match() { BOOST_ASSERT(0 == recursion_stack.back().idx); pstate = recursion_stack.back().preturn_address; + push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, m_presult, &recursion_stack.back().results); *m_presult = recursion_stack.back().results; - push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, &recursion_stack.back().results); recursion_stack.pop_back(); return true; } @@ -1181,10 +1192,15 @@ bool perl_matcher::skip_until_paren(int index, { // Unenclosed closing ), occurs when (*ACCEPT) is inside some other // parenthesis which may or may not have other side effects associated with it. + const re_syntax_base* sp = pstate; match_endmark(); if(!pstate) { unwind(true); + // unwind may leave pstate NULL if we've unwound a forward lookahead, in which + // case just move to the next state and keep looking... + if (!pstate) + pstate = sp->next.p; } } continue; @@ -1757,14 +1773,18 @@ bool perl_matcher::unwind_non_greedy_repeat(boo template bool perl_matcher::unwind_recursion(bool r) { + // We are backtracking back inside a recursion, need to push the info + // back onto the recursion stack, and do so unconditionally, otherwise + // we can get mismatched pushes and pops... saved_recursion* pmp = static_cast*>(m_backup_state); - if(!r) + if (!r) { recursion_stack.push_back(recursion_info()); recursion_stack.back().idx = pmp->recursion_id; recursion_stack.back().preturn_address = pmp->preturn_address; - recursion_stack.back().results = pmp->results; + recursion_stack.back().results = pmp->prior_results; recursion_stack.back().location_of_start = position; + *m_presult = pmp->internal_results; } boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++); m_backup_state = pmp; @@ -1774,9 +1794,13 @@ bool perl_matcher::unwind_recursion(bool r) template bool perl_matcher::unwind_recursion_pop(bool r) { + // Backtracking out of a recursion, we must pop state off the recursion + // stack unconditionally to ensure matched pushes and pops: saved_state* pmp = static_cast(m_backup_state); - if(!r) + if (!r) { + *m_presult = recursion_stack.back().results; + position = recursion_stack.back().location_of_start; recursion_stack.pop_back(); } boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++); diff --git a/3rdparty/boost/boost/regex/v4/perl_matcher_recursive.hpp b/3rdparty/boost/boost/regex/v4/perl_matcher_recursive.hpp index 8eb23abfdc..6c33ba477f 100644 --- a/3rdparty/boost/boost/regex/v4/perl_matcher_recursive.hpp +++ b/3rdparty/boost/boost/regex/v4/perl_matcher_recursive.hpp @@ -423,7 +423,7 @@ bool perl_matcher::match_dot_repeat_slow() #pragma warning(push) #pragma warning(disable:4127) #endif - unsigned count = 0; + std::size_t count = 0; const re_repeat* rep = static_cast(pstate); re_syntax_base* psingle = rep->next.p; // match compulsary repeats first: @@ -497,7 +497,7 @@ bool perl_matcher::match_dot_repeat_fast() #pragma warning(disable:4267) #endif bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent); - std::size_t count = (std::min)(static_cast(::boost::BOOST_REGEX_DETAIL_NS::distance(position, last)), static_cast(greedy ? rep->max : rep->min)); + std::size_t count = (std::min)(static_cast(::boost::BOOST_REGEX_DETAIL_NS::distance(position, last)), greedy ? rep->max : rep->min); if(rep->min > count) { position = last; @@ -657,7 +657,7 @@ bool perl_matcher::match_set_repeat() #endif const re_repeat* rep = static_cast(pstate); const unsigned char* map = static_cast(rep->next.p)->_map; - unsigned count = 0; + std::size_t count = 0; // // start by working out how much we can skip: // @@ -753,7 +753,7 @@ bool perl_matcher::match_long_set_repeat() typedef typename traits::char_class_type char_class_type; const re_repeat* rep = static_cast(pstate); const re_set_long* set = static_cast*>(pstate->next.p); - unsigned count = 0; + std::size_t count = 0; // // start by working out how much we can skip: // diff --git a/3rdparty/boost/boost/regex/v4/regex_traits_defaults.hpp b/3rdparty/boost/boost/regex/v4/regex_traits_defaults.hpp index 2a2cf21d37..df9922dfd4 100644 --- a/3rdparty/boost/boost/regex/v4/regex_traits_defaults.hpp +++ b/3rdparty/boost/boost/regex/v4/regex_traits_defaults.hpp @@ -307,6 +307,7 @@ template boost::intmax_t global_toi(const charT*& p1, const charT* p2, int radix, const traits& t) { (void)t; // warning suppression + boost::intmax_t limit = (std::numeric_limits::max)() / radix; boost::intmax_t next_value = t.value(*p1, radix); if((p1 == p2) || (next_value < 0) || (next_value >= radix)) return -1; @@ -319,6 +320,8 @@ boost::intmax_t global_toi(const charT*& p1, const charT* p2, int radix, const t result *= radix; result += next_value; ++p1; + if (result > limit) + return -1; } return result; } @@ -330,11 +333,11 @@ inline const charT* get_escape_R_string() # pragma warning(push) # pragma warning(disable:4309 4245) #endif - static const charT e1[] = { '(', '?', '>', '\x0D', '\x0A', '?', - '|', '[', '\x0A', '\x0B', '\x0C', static_cast('\x85'), '\\', 'x', '{', '2', '0', '2', '8', '}', + static const charT e1[] = { '(', '?', '>', '\\', 'x', '0', 'D', '\\', 'x', '0', 'A', '?', + '|', '[', '\\', 'x', '0', 'A', '\\', 'x', '0', 'B', '\\', 'x', '0', 'C', static_cast('\x85'), '\\', 'x', '{', '2', '0', '2', '8', '}', '\\', 'x', '{', '2', '0', '2', '9', '}', ']', ')', '\0' }; - static const charT e2[] = { '(', '?', '>', '\x0D', '\x0A', '?', - '|', '[', '\x0A', '\x0B', '\x0C', static_cast('\x85'), ']', ')', '\0' }; + static const charT e2[] = { '(', '?', '>', '\\', 'x', '0', 'D', '\\', 'x', '0', 'A', '?', + '|', '[', '\\', 'x', '0', 'A', '\\', 'x', '0', 'B', '\\', 'x', '0', 'C', static_cast('\x85'), ']', ')', '\0' }; charT c = static_cast(0x2029u); bool b = (static_cast(c) == 0x2029u); @@ -352,8 +355,8 @@ inline const char* get_escape_R_string() # pragma warning(push) # pragma warning(disable:4309) #endif - static const char e2[] = { '(', '?', '>', '\x0D', '\x0A', '?', - '|', '[', '\x0A', '\x0B', '\x0C', '\x85', ']', ')', '\0' }; + static const char e2[] = { '(', '?', '>', '\\', 'x', '0', 'D', '\\', 'x', '0', 'A', '?', + '|', '[', '\\', 'x', '0', 'A', '\\', 'x', '0', 'B', '\\', 'x', '0', 'C', '\\', 'x', '8', '5', ']', ')', '\0' }; return e2; #ifdef BOOST_MSVC # pragma warning(pop) diff --git a/3rdparty/boost/boost/regex/v4/regex_workaround.hpp b/3rdparty/boost/boost/regex/v4/regex_workaround.hpp index f900720bfd..f245f90d4e 100644 --- a/3rdparty/boost/boost/regex/v4/regex_workaround.hpp +++ b/3rdparty/boost/boost/regex/v4/regex_workaround.hpp @@ -19,7 +19,7 @@ #ifndef BOOST_REGEX_WORKAROUND_HPP #define BOOST_REGEX_WORKAROUND_HPP - +#include #include #include #include diff --git a/3rdparty/boost/boost/signals2/deconstruct_ptr.hpp b/3rdparty/boost/boost/signals2/deconstruct_ptr.hpp index bdc11188ee..6c3611be7d 100644 --- a/3rdparty/boost/boost/signals2/deconstruct_ptr.hpp +++ b/3rdparty/boost/boost/signals2/deconstruct_ptr.hpp @@ -17,6 +17,7 @@ #include #include +#include #include #include #include @@ -40,15 +41,16 @@ namespace boost } inline void do_predestruct(const predestructible *ptr) { - try + BOOST_TRY { predestructible *nonconst_ptr = const_cast(ptr); nonconst_ptr->predestruct(); } - catch(...) + BOOST_CATCH(...) { BOOST_ASSERT(false); } + BOOST_CATCH_END } } diff --git a/3rdparty/boost/boost/signals2/detail/lwm_win32_cs.hpp b/3rdparty/boost/boost/signals2/detail/lwm_win32_cs.hpp index 462da03174..8ac63368ea 100644 --- a/3rdparty/boost/boost/signals2/detail/lwm_win32_cs.hpp +++ b/3rdparty/boost/boost/signals2/detail/lwm_win32_cs.hpp @@ -15,17 +15,22 @@ // MS compatible compilers support #pragma once -#if defined(_MSC_VER) +#if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif +#include #include #ifdef BOOST_USE_WINDOWS_H -# include -#endif -#include +#include + +#else + +struct _RTL_CRITICAL_SECTION; + +#endif namespace boost { @@ -33,6 +38,9 @@ namespace boost namespace signals2 { +namespace detail +{ + #ifndef BOOST_USE_WINDOWS_H struct critical_section @@ -50,26 +58,42 @@ struct critical_section }; #if BOOST_PLAT_WINDOWS_RUNTIME -extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(critical_section *, unsigned long, unsigned long); +extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(::_RTL_CRITICAL_SECTION *, unsigned long, unsigned long); #else -extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *); +extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(::_RTL_CRITICAL_SECTION *); #endif -extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *); -extern "C" __declspec(dllimport) int __stdcall TryEnterCriticalSection(critical_section *); -extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *); -extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *); +extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(::_RTL_CRITICAL_SECTION *); +extern "C" __declspec(dllimport) int __stdcall TryEnterCriticalSection(::_RTL_CRITICAL_SECTION *); +extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(::_RTL_CRITICAL_SECTION *); +extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(::_RTL_CRITICAL_SECTION *); -#else +typedef ::_RTL_CRITICAL_SECTION rtl_critical_section; + +#else // #ifndef BOOST_USE_WINDOWS_H typedef ::CRITICAL_SECTION critical_section; +#if BOOST_PLAT_WINDOWS_RUNTIME +using ::InitializeCriticalSectionEx; +#else +using ::InitializeCriticalSection; +#endif +using ::EnterCriticalSection; +using ::TryEnterCriticalSection; +using ::LeaveCriticalSection; +using ::DeleteCriticalSection; + +typedef ::CRITICAL_SECTION rtl_critical_section; + #endif // #ifndef BOOST_USE_WINDOWS_H +} // namespace detail + class mutex { private: - critical_section cs_; + boost::signals2::detail::critical_section cs_; mutex(mutex const &); mutex & operator=(mutex const &); @@ -79,26 +103,26 @@ public: mutex() { #if BOOST_PLAT_WINDOWS_RUNTIME - InitializeCriticalSectionEx(&cs_, 4000, 0); + boost::signals2::detail::InitializeCriticalSectionEx(reinterpret_cast< boost::signals2::detail::rtl_critical_section* >(&cs_), 4000, 0); #else - InitializeCriticalSection(&cs_); + boost::signals2::detail::InitializeCriticalSection(reinterpret_cast< boost::signals2::detail::rtl_critical_section* >(&cs_)); #endif } ~mutex() { - DeleteCriticalSection(&cs_); + boost::signals2::detail::DeleteCriticalSection(reinterpret_cast< boost::signals2::detail::rtl_critical_section* >(&cs_)); } void lock() { - EnterCriticalSection(&cs_); + boost::signals2::detail::EnterCriticalSection(reinterpret_cast< boost::signals2::detail::rtl_critical_section* >(&cs_)); } // TryEnterCriticalSection only exists on Windows NT 4.0 and later #if (defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)) bool try_lock() { - return TryEnterCriticalSection(&cs_) != 0; + return boost::signals2::detail::TryEnterCriticalSection(reinterpret_cast< boost::signals2::detail::rtl_critical_section* >(&cs_)) != 0; } #else bool try_lock() @@ -109,7 +133,7 @@ public: #endif void unlock() { - LeaveCriticalSection(&cs_); + boost::signals2::detail::LeaveCriticalSection(reinterpret_cast< boost::signals2::detail::rtl_critical_section* >(&cs_)); } }; diff --git a/3rdparty/boost/boost/signals2/last_value.hpp b/3rdparty/boost/boost/signals2/last_value.hpp index 99fb6afbc3..1dd0712eaf 100644 --- a/3rdparty/boost/boost/signals2/last_value.hpp +++ b/3rdparty/boost/boost/signals2/last_value.hpp @@ -52,7 +52,7 @@ namespace boost { ++first; } if(value) return value.get(); - throw no_slots_error(); + boost::throw_exception(no_slots_error()); } }; diff --git a/3rdparty/boost/boost/signals2/slot_base.hpp b/3rdparty/boost/boost/signals2/slot_base.hpp index a9db4a92d8..e297180e49 100644 --- a/3rdparty/boost/boost/signals2/slot_base.hpp +++ b/3rdparty/boost/boost/signals2/slot_base.hpp @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -67,7 +68,6 @@ namespace boost typedef std::vector locked_container_type; const tracked_container_type& tracked_objects() const {return _tracked_objects;} - #ifndef BOOST_NO_EXCEPTIONS locked_container_type lock() const { locked_container_type locked_objects; @@ -77,12 +77,11 @@ namespace boost locked_objects.push_back(apply_visitor(detail::lock_weak_ptr_visitor(), *it)); if(apply_visitor(detail::expired_weak_ptr_visitor(), *it)) { - throw expired_slot(); + boost::throw_exception(expired_slot()); } } return locked_objects; } - #endif bool expired() const { tracked_container_type::const_iterator it; diff --git a/3rdparty/boost/boost/smart_ptr/detail/lwm_win32_cs.hpp b/3rdparty/boost/boost/smart_ptr/detail/lwm_win32_cs.hpp index 7d3e156166..d8dccb0141 100644 --- a/3rdparty/boost/boost/smart_ptr/detail/lwm_win32_cs.hpp +++ b/3rdparty/boost/boost/smart_ptr/detail/lwm_win32_cs.hpp @@ -61,10 +61,23 @@ extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(::_RTL_CRIT extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(::_RTL_CRITICAL_SECTION *); extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(::_RTL_CRITICAL_SECTION *); -#else +typedef ::_RTL_CRITICAL_SECTION rtl_critical_section; + +#else // #ifndef BOOST_USE_WINDOWS_H typedef ::CRITICAL_SECTION critical_section; +#if BOOST_PLAT_WINDOWS_RUNTIME +using ::InitializeCriticalSectionEx; +#else +using ::InitializeCriticalSection; +#endif +using ::EnterCriticalSection; +using ::LeaveCriticalSection; +using ::DeleteCriticalSection; + +typedef ::CRITICAL_SECTION rtl_critical_section; + #endif // #ifndef BOOST_USE_WINDOWS_H class lightweight_mutex @@ -81,15 +94,15 @@ public: lightweight_mutex() { #if BOOST_PLAT_WINDOWS_RUNTIME - boost::detail::InitializeCriticalSectionEx(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_), 4000, 0); + boost::detail::InitializeCriticalSectionEx(reinterpret_cast< rtl_critical_section* >(&cs_), 4000, 0); #else - boost::detail::InitializeCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_)); + boost::detail::InitializeCriticalSection(reinterpret_cast< rtl_critical_section* >(&cs_)); #endif } ~lightweight_mutex() { - boost::detail::DeleteCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_)); + boost::detail::DeleteCriticalSection(reinterpret_cast< rtl_critical_section* >(&cs_)); } class scoped_lock; @@ -108,12 +121,12 @@ public: explicit scoped_lock(lightweight_mutex & m): m_(m) { - boost::detail::EnterCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_.cs_)); + boost::detail::EnterCriticalSection(reinterpret_cast< rtl_critical_section* >(&m_.cs_)); } ~scoped_lock() { - boost::detail::LeaveCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_.cs_)); + boost::detail::LeaveCriticalSection(reinterpret_cast< rtl_critical_section* >(&m_.cs_)); } }; }; diff --git a/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_clang.hpp b/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_clang.hpp index 8b3bfad9b6..5d6e073d95 100644 --- a/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_clang.hpp +++ b/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_clang.hpp @@ -70,8 +70,8 @@ private: sp_counted_base( sp_counted_base const & ); sp_counted_base & operator= ( sp_counted_base const & ); - atomic_int_least32_t use_count_; // #shared - atomic_int_least32_t weak_count_; // #weak + (#shared != 0) + atomic_int_least32_t use_count_; // #shared + atomic_int_least32_t weak_count_; // #weak + (#shared != 0) public: diff --git a/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp b/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp index 76ac2a612d..c3175cf8ed 100644 --- a/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp +++ b/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp @@ -38,7 +38,9 @@ inline void atomic_increment( int * pw ) ( "0:\n\t" ".set push\n\t" +#if !defined(__mips_isa_rev) || (__mips_isa_rev < 6) ".set mips2\n\t" +#endif "ll %0, %1\n\t" "addiu %0, 1\n\t" "sc %0, %1\n\t" @@ -59,7 +61,9 @@ inline int atomic_decrement( int * pw ) ( "0:\n\t" ".set push\n\t" +#if !defined(__mips_isa_rev) || (__mips_isa_rev < 6) ".set mips2\n\t" +#endif "ll %1, %2\n\t" "addiu %0, %1, -1\n\t" "sc %0, %2\n\t" @@ -85,7 +89,9 @@ inline int atomic_conditional_increment( int * pw ) ( "0:\n\t" ".set push\n\t" +#if !defined(__mips_isa_rev) || (__mips_isa_rev < 6) ".set mips2\n\t" +#endif "ll %0, %2\n\t" "beqz %0, 1f\n\t" "addiu %1, %0, 1\n\t" diff --git a/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp b/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp index 7a188f8a66..9f562b9b4a 100644 --- a/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp +++ b/3rdparty/boost/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp @@ -64,8 +64,8 @@ private: sp_counted_base( sp_counted_base const & ); sp_counted_base & operator= ( sp_counted_base const & ); - std::atomic_int_least32_t use_count_; // #shared - std::atomic_int_least32_t weak_count_; // #weak + (#shared != 0) + std::atomic_int_least32_t use_count_; // #shared + std::atomic_int_least32_t weak_count_; // #weak + (#shared != 0) public: diff --git a/3rdparty/boost/boost/smart_ptr/detail/sp_interlocked.hpp b/3rdparty/boost/boost/smart_ptr/detail/sp_interlocked.hpp index 79cae14a37..68ce292fcc 100644 --- a/3rdparty/boost/boost/smart_ptr/detail/sp_interlocked.hpp +++ b/3rdparty/boost/boost/smart_ptr/detail/sp_interlocked.hpp @@ -32,6 +32,11 @@ // MinGW-w64 provides intrin.h for both 32 and 64-bit targets. # define BOOST_SP_HAS_INTRIN_H +#elif defined( __LP64__ ) + +// We have to use intrin.h on Cygwin 64 +# define BOOST_SP_HAS_INTRIN_H + // Intel C++ on Windows on VC10+ stdlib #elif defined( BOOST_INTEL_WIN ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520 diff --git a/3rdparty/boost/boost/smart_ptr/detail/yield_k.hpp b/3rdparty/boost/boost/smart_ptr/detail/yield_k.hpp index f8ca6b6467..403f32f98b 100644 --- a/3rdparty/boost/boost/smart_ptr/detail/yield_k.hpp +++ b/3rdparty/boost/boost/smart_ptr/detail/yield_k.hpp @@ -60,18 +60,24 @@ namespace detail { #if !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME -#if !BOOST_COMP_CLANG || !defined __MINGW32__ - extern "C" void __stdcall Sleep( unsigned long ms ); -#else -#include <_mingw.h> -#if !defined __MINGW64_VERSION_MAJOR - extern "C" void __stdcall Sleep( unsigned long ms ); + +#if defined(__clang__) && defined(__x86_64__) +// clang x64 warns that __stdcall is ignored +# define BOOST_SP_STDCALL #else - extern "C" __declspec(dllimport) void __stdcall Sleep( unsigned long ms ); -#endif +# define BOOST_SP_STDCALL __stdcall #endif + +#if defined(__LP64__) // Cygwin 64 + extern "C" __declspec(dllimport) void BOOST_SP_STDCALL Sleep( unsigned int ms ); +#else + extern "C" __declspec(dllimport) void BOOST_SP_STDCALL Sleep( unsigned long ms ); #endif +#undef BOOST_SP_STDCALL + +#endif // !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME + inline void yield( unsigned k ) { if( k < 4 ) diff --git a/3rdparty/boost/boost/smart_ptr/shared_ptr.hpp b/3rdparty/boost/boost/smart_ptr/shared_ptr.hpp index e8a302c74a..4ac0699ef6 100644 --- a/3rdparty/boost/boost/smart_ptr/shared_ptr.hpp +++ b/3rdparty/boost/boost/smart_ptr/shared_ptr.hpp @@ -1080,7 +1080,7 @@ template shared_ptr atomic_load( shared_ptr const * p ) BOOST_SP_ return *p; } -template inline shared_ptr atomic_load_explicit( shared_ptr const * p, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT +template inline shared_ptr atomic_load_explicit( shared_ptr const * p, /*memory_order mo*/ M ) BOOST_SP_NOEXCEPT { return atomic_load( p ); } @@ -1091,7 +1091,7 @@ template void atomic_store( shared_ptr * p, shared_ptr r ) BOOST_ p->swap( r ); } -template inline void atomic_store_explicit( shared_ptr * p, shared_ptr r, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT +template inline void atomic_store_explicit( shared_ptr * p, shared_ptr r, /*memory_order mo*/ M ) BOOST_SP_NOEXCEPT { atomic_store( p, r ); // std::move( r ) } @@ -1107,7 +1107,7 @@ template shared_ptr atomic_exchange( shared_ptr * p, shared_ptr shared_ptr inline atomic_exchange_explicit( shared_ptr * p, shared_ptr r, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT +template shared_ptr inline atomic_exchange_explicit( shared_ptr * p, shared_ptr r, /*memory_order mo*/ M ) BOOST_SP_NOEXCEPT { return atomic_exchange( p, r ); // std::move( r ) } @@ -1137,7 +1137,7 @@ template bool atomic_compare_exchange( shared_ptr * p, shared_ptr } } -template inline bool atomic_compare_exchange_explicit( shared_ptr * p, shared_ptr * v, shared_ptr w, /*memory_order success*/ int, /*memory_order failure*/ int ) BOOST_SP_NOEXCEPT +template inline bool atomic_compare_exchange_explicit( shared_ptr * p, shared_ptr * v, shared_ptr w, /*memory_order success*/ M, /*memory_order failure*/ M ) BOOST_SP_NOEXCEPT { return atomic_compare_exchange( p, v, w ); // std::move( w ) } diff --git a/3rdparty/boost/boost/tuple/detail/tuple_basic.hpp b/3rdparty/boost/boost/tuple/detail/tuple_basic.hpp index 5f26c7fdcb..879f0e90a9 100644 --- a/3rdparty/boost/boost/tuple/detail/tuple_basic.hpp +++ b/3rdparty/boost/boost/tuple/detail/tuple_basic.hpp @@ -35,13 +35,13 @@ #include // needed for the assignment from pair to tuple -#include "boost/type_traits/cv_traits.hpp" -#include "boost/type_traits/function_traits.hpp" -#include "boost/utility/swap.hpp" +#include +#include +#include -#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND +#include // needed for BOOST_WORKAROUND -#if BOOST_GCC >= 40700 +#if defined(BOOST_GCC) && (BOOST_GCC >= 40700) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif @@ -484,7 +484,7 @@ public: // access_traits::parameter_type takes non-reference types as const T& tuple() {} - tuple(typename access_traits::parameter_type t0) + explicit tuple(typename access_traits::parameter_type t0) : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull()) {} @@ -979,11 +979,9 @@ inline void swap(tuple& lhs, } // end of namespace boost -#if BOOST_GCC >= 40700 +#if defined(BOOST_GCC) && (BOOST_GCC >= 40700) #pragma GCC diagnostic pop #endif #endif // BOOST_TUPLE_BASIC_HPP - - diff --git a/3rdparty/boost/boost/tuple/tuple.hpp b/3rdparty/boost/boost/tuple/tuple.hpp index 433d4b3165..d71e7df0af 100644 --- a/3rdparty/boost/boost/tuple/tuple.hpp +++ b/3rdparty/boost/boost/tuple/tuple.hpp @@ -8,7 +8,7 @@ // For more information, see http://www.boost.org -// ----------------------------------------------------------------- +// ----------------------------------------------------------------- #ifndef BOOST_TUPLE_HPP #define BOOST_TUPLE_HPP @@ -20,15 +20,15 @@ namespace boost { namespace python { class tuple; }} #endif -#include "boost/config.hpp" -#include "boost/static_assert.hpp" +#include +#include // other compilers -#include "boost/ref.hpp" -#include "boost/tuple/detail/tuple_basic.hpp" +#include +#include -namespace boost { +namespace boost { using tuples::tuple; using tuples::make_tuple; @@ -47,7 +47,7 @@ inline typename tuples::access_traits< >::non_const_type get(tuples::cons& c) { return tuples::get(c); -} +} // get function for const cons-lists, returns a const reference to // the element. If the element is a reference, returns the reference // as such (that is, can return a non-const reference) @@ -60,7 +60,7 @@ get(const tuples::cons& c) { } #endif // BOOST_NO_USING_TEMPLATE - + } // end namespace boost diff --git a/3rdparty/boost/boost/type_index.hpp b/3rdparty/boost/boost/type_index.hpp index 0310e2027b..5311ac8795 100644 --- a/3rdparty/boost/boost/type_index.hpp +++ b/3rdparty/boost/boost/type_index.hpp @@ -1,5 +1,5 @@ // -// Copyright (c) Antony Polukhin, 2012-2014. +// Copyright (c) Antony Polukhin, 2012-2018. // // 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 6832adeaf7..a59b2d80a7 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) Antony Polukhin, 2013-2016. +// Copyright (c) Antony Polukhin, 2013-2018. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -22,7 +22,7 @@ #include #include -#include +#include #include #include #include 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 4eb2017ffc..7a55350b9e 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) Antony Polukhin, 2012-2016. +// Copyright (c) Antony Polukhin, 2012-2018. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -15,7 +15,7 @@ #include #include -#include +#include #ifdef BOOST_HAS_PRAGMA_ONCE # pragma once @@ -59,6 +59,14 @@ // sizeof("static const char *boost::detail::ctti<") - 1, sizeof("]") - 1, true, "int>::n() [T = int" // note: checked on 3.1, 3.4 BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(39, 1, true, "T = ") +#elif defined(__EDG__) && !defined(BOOST_NO_CXX14_CONSTEXPR) + // sizeof("static cha boost::detail::ctti::s() [with I = 40U, T = ") - 1, sizeof("]") - 1 + // note: checked on 4.14 + BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(58, 1, false, "") +#elif defined(__EDG__) && defined(BOOST_NO_CXX14_CONSTEXPR) + // sizeof("static const char *boost::detail::ctti::n() [with T = ") - 1, sizeof("]") - 1 + // note: checked on 4.14 + BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(57, 1, false, "") #elif defined(__GNUC__) && (__GNUC__ < 7) && !defined(BOOST_NO_CXX14_CONSTEXPR) // sizeof("static constexpr char boost::detail::ctti::s() [with unsigned int I = 0u; T = ") - 1, sizeof("]") - 1 BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(81, 1, false, "") @@ -98,7 +106,7 @@ namespace boost { namespace typeindex { namespace detail { } template - BOOST_CXX14_CONSTEXPR inline const char* skip_begining_runtime(const char* begin, boost::mpl::false_) BOOST_NOEXCEPT { + BOOST_CXX14_CONSTEXPR inline const char* skip_begining_runtime(const char* begin, boost::false_type) BOOST_NOEXCEPT { return begin; } @@ -140,7 +148,7 @@ namespace boost { namespace typeindex { namespace detail { } template - BOOST_CXX14_CONSTEXPR inline const char* skip_begining_runtime(const char* begin, boost::mpl::true_) BOOST_NOEXCEPT { + BOOST_CXX14_CONSTEXPR inline const char* skip_begining_runtime(const char* begin, boost::true_type) BOOST_NOEXCEPT { const char* const it = constexpr_search( begin, begin + ArrayLength, ctti_skip_until_runtime, ctti_skip_until_runtime + sizeof(ctti_skip_until_runtime) - 1 @@ -153,7 +161,7 @@ namespace boost { namespace typeindex { namespace detail { assert_compile_time_legths<(ArrayLength > ctti_skip_size_at_begin + ctti_skip_size_at_end)>(); return skip_begining_runtime( begin + ctti_skip_size_at_begin, - boost::mpl::bool_() + boost::integral_constant() ); } diff --git a/3rdparty/boost/boost/type_index/stl_type_index.hpp b/3rdparty/boost/boost/type_index/stl_type_index.hpp index dcc532d03b..0f7dae8cec 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) Antony Polukhin, 2013-2017. +// Copyright (c) Antony Polukhin, 2013-2018. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -32,25 +32,20 @@ #include #include #include +#include #include #include #include #include #include -#include -#include -#if !((defined(_MSC_VER) && _MSC_VER > 1600) \ - || (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__)) \ - || (defined(__GNUC__) && __GNUC__ > 4 && __cplusplus >= 201103 )) -# include -#endif +#include #if (defined(__EDG_VERSION__) && __EDG_VERSION__ < 245) \ || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 744) # include # include -# include +# include #endif #ifdef BOOST_HAS_PRAGMA_ONCE @@ -236,10 +231,10 @@ inline stl_type_index stl_type_index::type_id() BOOST_NOEXCEPT { // Old EDG-based compilers seem to mistakenly distinguish 'integral' from 'signed integral' // in typeid() expressions. Full template specialization for 'integral' fixes that issue: - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< - boost::is_signed, + typedef BOOST_DEDUCED_TYPENAME boost::conditional< + boost::is_signed::value, boost::make_signed, - boost::mpl::identity + boost::type_identity >::type no_cvr_prefinal_lazy_t; typedef BOOST_DEDUCED_TYPENAME no_cvr_prefinal_t::type no_cvr_t; @@ -256,8 +251,8 @@ namespace detail { template inline stl_type_index stl_type_index::type_id_with_cvr() BOOST_NOEXCEPT { - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< - boost::mpl::or_, boost::is_const, boost::is_volatile >, + typedef BOOST_DEDUCED_TYPENAME boost::conditional< + boost::is_reference::value || boost::is_const::value || boost::is_volatile::value, detail::cvr_saver, T >::type type; diff --git a/3rdparty/boost/boost/type_index/type_index_facade.hpp b/3rdparty/boost/boost/type_index/type_index_facade.hpp index 110000c33d..e6dde8f3f9 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) Antony Polukhin, 2013-2015. +// Copyright (c) Antony Polukhin, 2013-2018. // // // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -10,6 +10,7 @@ #define BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP #include +#include #include #include @@ -25,11 +26,6 @@ # pragma once #endif -// Forward declaration from #include -namespace boost { - template std::size_t hash_range(It, It); -} - namespace boost { namespace typeindex { /// \class type_index_facade @@ -103,7 +99,7 @@ public: /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw. /// \return Hash code of a type. By default hashes types by raw_name(). - /// \note Derived class header \b must include , \b unless this function is redefined in + /// \note Derived class header \b must include , \b unless this function is redefined in /// Derived class to not use boost::hash_range(). inline std::size_t hash_code() const BOOST_NOEXCEPT { const char* const name_raw = derived().raw_name(); @@ -289,7 +285,7 @@ inline std::basic_ostream& operator<<( #endif // BOOST_NO_IOSTREAM /// This free function is used by Boost's unordered containers. -/// \note has to be included if this function is used. +/// \note has to be included if this function is used. template inline std::size_t hash_value(const type_index_facade& lhs) BOOST_NOEXCEPT { return static_cast(lhs).hash_code(); diff --git a/3rdparty/boost/boost/type_traits/conditional.hpp b/3rdparty/boost/boost/type_traits/conditional.hpp index 5890198ba2..ec31d8b0bb 100644 --- a/3rdparty/boost/boost/type_traits/conditional.hpp +++ b/3rdparty/boost/boost/type_traits/conditional.hpp @@ -9,6 +9,8 @@ #ifndef BOOST_TT_CONDITIONAL_HPP_INCLUDED #define BOOST_TT_CONDITIONAL_HPP_INCLUDED +#include + namespace boost { template struct conditional { typedef T type; }; diff --git a/3rdparty/boost/boost/type_traits/detail/config.hpp b/3rdparty/boost/boost/type_traits/detail/config.hpp index ebb1dd65f0..2113c438a5 100644 --- a/3rdparty/boost/boost/type_traits/detail/config.hpp +++ b/3rdparty/boost/boost/type_traits/detail/config.hpp @@ -13,7 +13,7 @@ #include #endif #include -#include +#include // // whenever we have a conversion function with ellipses @@ -67,6 +67,17 @@ #define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x) #define BOOST_TT_BROKEN_COMPILER_SPEC(x) +// +// Can we implement "accurate" binary operator detection: +// +#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1900) && !BOOST_WORKAROUND(BOOST_GCC, < 40900) +# define BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION +#endif + +#if defined(__clang__) && (__clang_major__ == 3) && (__clang_minor__ < 2) && defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) +#undef BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION +#endif + #endif // BOOST_TT_CONFIG_HPP_INCLUDED diff --git a/3rdparty/boost/boost/type_traits/detail/has_binary_operator.hpp b/3rdparty/boost/boost/type_traits/detail/has_binary_operator.hpp index 039a6bb778..ec6e52e73b 100644 --- a/3rdparty/boost/boost/type_traits/detail/has_binary_operator.hpp +++ b/3rdparty/boost/boost/type_traits/detail/has_binary_operator.hpp @@ -7,19 +7,7 @@ // See http://www.boost.org/libs/type_traits for most recent version including documentation. #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include // cannot include this header without getting warnings of the kind: // gcc: @@ -37,12 +25,78 @@ # pragma GCC system_header #elif defined(BOOST_MSVC) # pragma warning ( push ) -# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913) +# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133) # if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) # pragma warning ( disable : 6334) # endif #endif +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template > + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) : public boost::false_type {}; + + template + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp)::type>() BOOST_TT_TRAIT_OP std::declval::type>())> > + : public boost::integral_constant::type>() BOOST_TT_TRAIT_OP std::declval::type>()), Ret>::value> {}; + + template > + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) : public boost::false_type {}; + + template + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp)::type>() BOOST_TT_TRAIT_OP std::declval::type>())> > + : public boost::integral_constant::type>() BOOST_TT_TRAIT_OP std::declval::type>())>::value> {}; + + template > + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) : public boost::false_type {}; + + template + struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp)::type>() BOOST_TT_TRAIT_OP std::declval::type>())> > + : public boost::true_type {}; + + } + + template + struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) {}; + template + struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) {}; + template + struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) {}; + + +} + +#else + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + namespace boost { namespace detail { @@ -217,6 +271,9 @@ struct BOOST_TT_TRAIT_NAME : public integral_constant -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif #else #undef BOOST_STATIC_CONSTANT @@ -172,5 +432,13 @@ struct is_function_ptr_helper { template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; @#endif +@#if __cpp_noexcept_function_type +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; +@#endif +@#endif #undef BOOST_PP_COUNTER #endif // BOOST_PP_IS_ITERATING diff --git a/3rdparty/boost/boost/type_traits/detail/is_likely_lambda.hpp b/3rdparty/boost/boost/type_traits/detail/is_likely_lambda.hpp new file mode 100644 index 0000000000..6da8acafce --- /dev/null +++ b/3rdparty/boost/boost/type_traits/detail/is_likely_lambda.hpp @@ -0,0 +1,94 @@ +/* Copyright 2017 Joaquin M Lopez Munoz. + * 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/poly_collection for library home page. + */ + +#ifndef BOOST_TT_DETAIL_IS_LIKELY_STATELESS_LAMBDA_HPP +#define BOOST_TT_DETAIL_IS_LIKELY_STATELESS_LAMBDA_HPP + +#if defined(_MSC_VER) +#pragma once +#endif + +#include +#include + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) +// +// We don't need or use this, just define a dummy class: +// +namespace boost{ namespace type_traits_detail{ + +template +struct is_likely_stateless_lambda : public false_type {}; + +}} + +#elif !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !BOOST_WORKAROUND(BOOST_MSVC, < 1900) + +#include +#include + +namespace boost{ + +namespace type_traits_detail{ + +/* Stateless lambda expressions have one (and only one) call operator and are + * convertible to a function pointer with the same signature. Non-lambda types + * could satisfy this too, hence the "likely" qualifier. + */ + +template +struct has_one_operator_call_helper +{ + template static boost::true_type test(decltype(&Q::operator())*); + template static boost::false_type test(...); + + using type=decltype(test(nullptr)); +}; + +template +using has_one_operator_call=typename has_one_operator_call_helper::type; + +template +struct equivalent_function_pointer +{ + template + static auto helper(R (Q::*)(Args...)const)->R(*)(Args...); + template + static auto helper(R (Q::*)(Args...))->R(*)(Args...); + + using type=decltype(helper(&T::operator())); +}; + +template +struct is_likely_stateless_lambda : false_type{}; + +template +struct is_likely_stateless_lambda< + T, + typename boost::enable_if_c::value>::type> : + boost::is_convertible::type +>{}; + +} /* namespace type_traits_detail */ + +} /* namespace boost */ + +#else + // + // Can't implement this: + // +namespace boost { + namespace type_traits_detail { + + template + struct is_likely_stateless_lambda : public boost::integral_constant {}; +}} + +#endif +#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 5698a74897..dcc6e2a0a1 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 @@ -46,628 +46,1200 @@ struct is_mem_fun_pointer_impl // cpp -I../../../ -DBOOST_TT_PREPROCESSING_MODE -x c++ -P filename template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif #if !defined(BOOST_TT_NO_CV_FUNC_TEST) template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - #if !defined(BOOST_TT_NO_CV_FUNC_TEST) -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; - -template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#endif +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif +#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#endif #endif #else @@ -690,32 +1262,65 @@ struct is_mem_fun_pointer_impl -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @#endif @#if !defined(BOOST_TT_NO_CV_FUNC_TEST) template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template -struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +@#endif +@#endif + +@#if __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 +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; @#endif + +@#if !defined(BOOST_TT_NO_CV_FUNC_TEST) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; + +@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +@#endif +@#endif + @#endif #undef BOOST_PP_COUNTER 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 5e31693111..c186db7bac 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 @@ -28,9 +28,9 @@ #define PPI #include PPI #undef PPI -#define +#define PPI #include PPI -#undef +#undef PPI #endif namespace boost { diff --git a/3rdparty/boost/boost/type_traits/has_minus.hpp b/3rdparty/boost/boost/type_traits/has_minus.hpp index 5e13c16014..3f6271a57b 100644 --- a/3rdparty/boost/boost/type_traits/has_minus.hpp +++ b/3rdparty/boost/boost/type_traits/has_minus.hpp @@ -9,6 +9,97 @@ #ifndef BOOST_TT_HAS_MINUS_HPP_INCLUDED #define BOOST_TT_HAS_MINUS_HPP_INCLUDED +#include +#include + +// cannot include this header without getting warnings of the kind: +// gcc: +// warning: value computed is not used +// warning: comparison between signed and unsigned integer expressions +// msvc: +// warning C4018: '<' : signed/unsigned mismatch +// warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data +// warning C4547: '*' : operator before comma has no effect; expected operator with side-effect +// warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning) +// warning C4804: '<' : unsafe use of type 'bool' in operation +// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation +// cannot find another implementation -> declared as system header to suppress these warnings. +#if defined(__GNUC__) +# pragma GCC system_header +#elif defined(BOOST_MSVC) +# pragma warning ( push ) +# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133) +# if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +# pragma warning ( disable : 6334) +# endif +#endif + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template > + struct has_minus_ret_imp : public boost::false_type {}; + + template + struct has_minus_ret_imp::type>() - std::declval::type>())> > + : public boost::integral_constant::type>() - std::declval::type>()), Ret>::value> {}; + + template > + struct has_minus_void_imp : public boost::false_type {}; + + template + struct has_minus_void_imp::type>() - std::declval::type>())> > + : public boost::integral_constant::type>() - std::declval::type>())>::value> {}; + + template > + struct has_minus_dc_imp : public boost::false_type {}; + + template + struct has_minus_dc_imp::type>() - std::declval::type>())> > + : public boost::true_type {}; + + template + struct has_minus_ret_filter : public boost::binary_op_detail::has_minus_ret_imp {}; + template + struct has_minus_ret_filter : public boost::binary_op_detail::has_minus_void_imp {}; + template + struct has_minus_ret_filter : public boost::binary_op_detail::has_minus_dc_imp {}; + + template + struct has_minus_void_ptr_filter : public boost::binary_op_detail::has_minus_ret_filter {}; + template + struct has_minus_void_ptr_filter : public boost::false_type {}; + + } + + template + struct has_minus : + public boost::binary_op_detail::has_minus_void_ptr_filter< + T, U, Ret, + boost::is_void::type>::type>::value + || boost::is_void::type>::type>::value> {}; + + +} + +#else + + #define BOOST_TT_TRAIT_NAME has_minus #define BOOST_TT_TRAIT_OP - #define BOOST_TT_FORBIDDEN_IF\ @@ -50,6 +141,7 @@ )\ ) +#define BOOST_TT_FORBIDDEN_IF_NEW (boost::is_void::type>::type>::value || boost::is_void::type>::type>::value) #include @@ -58,3 +150,9 @@ #undef BOOST_TT_FORBIDDEN_IF #endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + +#endif diff --git a/3rdparty/boost/boost/type_traits/has_minus_assign.hpp b/3rdparty/boost/boost/type_traits/has_minus_assign.hpp index b53474e756..936ffedb47 100644 --- a/3rdparty/boost/boost/type_traits/has_minus_assign.hpp +++ b/3rdparty/boost/boost/type_traits/has_minus_assign.hpp @@ -6,8 +6,100 @@ // // See http://www.boost.org/libs/type_traits for most recent version including documentation. -#ifndef BOOST_TT_HAS_MINUS_ASSIGN_HPP_INCLUDED -#define BOOST_TT_HAS_MINUS_ASSIGN_HPP_INCLUDED +#ifndef BOOST_TT_has_minus_assign_ASSIGN_HPP_INCLUDED +#define BOOST_TT_has_minus_assign_ASSIGN_HPP_INCLUDED + +#include +#include + +// cannot include this header without getting warnings of the kind: +// gcc: +// warning: value computed is not used +// warning: comparison between signed and unsigned integer expressions +// msvc: +// warning C4018: '<' : signed/unsigned mismatch +// warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data +// warning C4547: '*' : operator before comma has no effect; expected operator with side-effect +// warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning) +// warning C4804: '<' : unsafe use of type 'bool' in operation +// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation +// cannot find another implementation -> declared as system header to suppress these warnings. +#if defined(__GNUC__) +# pragma GCC system_header +#elif defined(BOOST_MSVC) +# pragma warning ( push ) +# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133) +# if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +# pragma warning ( disable : 6334) +# endif +#endif + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template > + struct has_minus_assign_ret_imp : public boost::false_type {}; + + template + struct has_minus_assign_ret_imp::type>() -= std::declval::type>())> > + : public boost::integral_constant::type>() -= std::declval::type>()), Ret>::value> {}; + + template > + struct has_minus_assign_void_imp : public boost::false_type {}; + + template + struct has_minus_assign_void_imp::type>() -= std::declval::type>())> > + : public boost::integral_constant::type>() -= std::declval::type>())>::value> {}; + + template > + struct has_minus_assign_dc_imp : public boost::false_type {}; + + template + struct has_minus_assign_dc_imp::type>() -= std::declval::type>())> > + : public boost::true_type {}; + + template + struct has_minus_assign_ret_filter : public boost::binary_op_detail::has_minus_assign_ret_imp {}; + template + struct has_minus_assign_ret_filter : public boost::binary_op_detail::has_minus_assign_void_imp {}; + template + struct has_minus_assign_ret_filter : public boost::binary_op_detail::has_minus_assign_dc_imp {}; + + template + struct has_minus_assign_void_ptr_filter : public boost::binary_op_detail::has_minus_assign_ret_filter {}; + template + struct has_minus_assign_void_ptr_filter : public boost::false_type {}; + + } + + template + struct has_minus_assign : + public boost::binary_op_detail::has_minus_assign_void_ptr_filter< + T, U, Ret, + boost::is_void::type>::type>::value + || boost::is_void::type>::type>::value + || (boost::is_pointer::type>::value && boost::is_pointer::type>::value)> {}; + + +} + +#else #define BOOST_TT_TRAIT_NAME has_minus_assign #define BOOST_TT_TRAIT_OP -= @@ -63,3 +155,9 @@ #undef BOOST_TT_FORBIDDEN_IF #endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + +#endif diff --git a/3rdparty/boost/boost/type_traits/has_plus_assign.hpp b/3rdparty/boost/boost/type_traits/has_plus_assign.hpp index 5ef6f23289..cf012e243c 100644 --- a/3rdparty/boost/boost/type_traits/has_plus_assign.hpp +++ b/3rdparty/boost/boost/type_traits/has_plus_assign.hpp @@ -9,6 +9,95 @@ #ifndef BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED #define BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED +#include +#include + +// cannot include this header without getting warnings of the kind: +// gcc: +// warning: value computed is not used +// warning: comparison between signed and unsigned integer expressions +// msvc: +// warning C4018: '<' : signed/unsigned mismatch +// warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data +// warning C4547: '*' : operator before comma has no effect; expected operator with side-effect +// warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning) +// warning C4804: '<' : unsafe use of type 'bool' in operation +// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation +// cannot find another implementation -> declared as system header to suppress these warnings. +#if defined(__GNUC__) +# pragma GCC system_header +#elif defined(BOOST_MSVC) +# pragma warning ( push ) +# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133) +# if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +# pragma warning ( disable : 6334) +# endif +#endif + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template > + struct has_plus_assign_ret_imp : public boost::false_type {}; + + template + struct has_plus_assign_ret_imp::type>() += std::declval::type>())> > + : public boost::integral_constant::type>() += std::declval::type>()), Ret>::value> {}; + + template > + struct has_plus_assign_void_imp : public boost::false_type {}; + + template + struct has_plus_assign_void_imp::type>() += std::declval::type>())> > + : public boost::integral_constant::type>() += std::declval::type>())>::value> {}; + + template > + struct has_plus_assign_dc_imp : public boost::false_type {}; + + template + struct has_plus_assign_dc_imp::type>() += std::declval::type>())> > + : public boost::true_type {}; + + template + struct has_plus_assign_filter_ret : public boost::binary_op_detail:: has_plus_assign_ret_imp {}; + template + struct has_plus_assign_filter_ret : public boost::binary_op_detail:: has_plus_assign_void_imp {}; + template + struct has_plus_assign_filter_ret : public boost::binary_op_detail:: has_plus_assign_dc_imp {}; + + template + struct has_plus_assign_filter_impossible : public boost::binary_op_detail:: has_plus_assign_filter_ret {}; + template + struct has_plus_assign_filter_impossible : public boost::false_type {}; + + } + + template + struct has_plus_assign : public boost::binary_op_detail:: has_plus_assign_filter_impossible ::type>::value && boost::is_pointer::type>::value && !boost::is_same::type>::type>::value> {}; + +} + +#else + #define BOOST_TT_TRAIT_NAME has_plus_assign #define BOOST_TT_TRAIT_OP += #define BOOST_TT_FORBIDDEN_IF\ @@ -64,3 +153,9 @@ #undef BOOST_TT_FORBIDDEN_IF #endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + +#endif diff --git a/3rdparty/boost/boost/type_traits/integral_constant.hpp b/3rdparty/boost/boost/type_traits/integral_constant.hpp index ae2448d070..1b36dbd2c3 100644 --- a/3rdparty/boost/boost/type_traits/integral_constant.hpp +++ b/3rdparty/boost/boost/type_traits/integral_constant.hpp @@ -13,7 +13,8 @@ || BOOST_WORKAROUND(__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)) ) + || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) )\ + || defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) namespace boost{ @@ -55,17 +56,12 @@ namespace boost{ typedef T value_type; typedef integral_constant type; static const T value = val; - // - // This helper function is just to disable type-punning - // warnings from GCC: - // - template - static U& dereference(U* p) { return *p; } operator const mpl::integral_c& ()const { static const char data[sizeof(long)] = { 0 }; - return dereference(reinterpret_cast*>(&data)); + static const void* pdata = data; + return *(reinterpret_cast*>(pdata)); } BOOST_CONSTEXPR operator T()const { return val; } }; @@ -80,17 +76,12 @@ namespace boost{ typedef bool value_type; typedef integral_constant type; static const bool value = val; - // - // This helper function is just to disable type-punning - // warnings from GCC: - // - template - static T& dereference(T* p) { return *p; } operator const mpl::bool_& ()const { - static const char data = 0; - return dereference(reinterpret_cast*>(&data)); + static const char data[sizeof(long)] = { 0 }; + static const void* pdata = data; + return *(reinterpret_cast*>(pdata)); } BOOST_CONSTEXPR operator bool()const { return val; } }; diff --git a/3rdparty/boost/boost/type_traits/intrinsics.hpp b/3rdparty/boost/boost/type_traits/intrinsics.hpp index e2246be4d3..d41a61ec9a 100644 --- a/3rdparty/boost/boost/type_traits/intrinsics.hpp +++ b/3rdparty/boost/boost/type_traits/intrinsics.hpp @@ -122,19 +122,25 @@ // This one fails if the default alignment has been changed with /Zp: // # define BOOST_ALIGNMENT_OF(T) __alignof(T) -# if defined(_MSC_VER) && (_MSC_VER >= 1700) +# if defined(_MSC_VER) && (_MSC_VER >= 1800) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__is_trivially_constructible(T, T&&) || boost::is_pod::value) && ! ::boost::is_volatile::value && ! ::boost::is_reference::value) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__is_trivially_assignable(T, T&&) || boost::is_pod::value) && ! ::boost::is_const::value && !::boost::is_volatile::value && ! ::boost::is_reference::value) +# elif defined(_MSC_VER) && (_MSC_VER >= 1700) # define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || boost::is_pod::value) && ! ::boost::is_volatile::value && ! ::boost::is_reference::value) # define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || boost::is_pod::value) && ! ::boost::is_const::value && !::boost::is_volatile::value && ! ::boost::is_reference::value) # endif #ifndef BOOST_NO_CXX11_FINAL // This one doesn't quite always do the right thing on older VC++ versions -// we really need it when the final keyword is supporyted though: +// we really need it when the final keyword is supported though: # define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) #endif #if _MSC_FULL_VER >= 180020827 # define BOOST_IS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&)) # define BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) (__is_nothrow_constructible(T, T&&)) #endif +#if _MSC_VER >= 1800 +# define BOOST_IS_FINAL(T) __is_final(T) +#endif # define BOOST_HAS_TYPE_TRAITS_INTRINSICS #endif @@ -219,12 +225,14 @@ # if __has_feature(is_polymorphic) # define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) # endif -# if __has_feature(has_trivial_move_constructor) -# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T) && is_constructible::value && !::boost::is_volatile::value) +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +# if __has_extension(is_trivially_constructible) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_trivially_constructible(T, T&&) && is_constructible::value && !::boost::is_volatile::value) # endif -# if __has_feature(has_trivial_move_assign) -# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) && is_assignable::value && !::boost::is_volatile::value) +# if __has_extension(is_trivially_assignable) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_trivially_assignable(T&, T&&) && is_assignable::value && !::boost::is_volatile::value) # endif +#endif # if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) || !defined(__GNUC__) // GCC sometimes lies about alignment requirements // of type double on 32-bit unix platforms, use the @@ -266,7 +274,9 @@ # define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile::value && ! ::boost::is_const::value) # define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS) # define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS) +#if ((__GNUC__ * 100 + __GNUC_MINOR__) != 407) && ((__GNUC__ * 100 + __GNUC_MINOR__) != 408) # define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile::value && !is_reference::value && !is_array::value) +#endif # define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile::value && !is_const::value && !is_array::value) #endif # define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) @@ -276,7 +286,8 @@ # define BOOST_IS_CLASS(T) __is_class(T) # define BOOST_IS_ENUM(T) __is_enum(T) # define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) -# if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) +# if (!defined(unix) && !defined(__unix__) && \ + !(defined(__VXWORKS__) && defined(__i386__))) || defined(__LP64__) // GCC sometimes lies about alignment requirements // of type double on 32-bit unix platforms, use the // old implementation instead in that case: diff --git a/3rdparty/boost/boost/type_traits/is_assignable.hpp b/3rdparty/boost/boost/type_traits/is_assignable.hpp index 49d171616a..6a9474b2fd 100644 --- a/3rdparty/boost/boost/type_traits/is_assignable.hpp +++ b/3rdparty/boost/boost/type_traits/is_assignable.hpp @@ -12,6 +12,8 @@ #include // size_t #include #include +#include +#include namespace boost{ @@ -39,7 +41,10 @@ namespace boost{ } - template struct is_assignable : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)>{}; + template struct is_assignable : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_assignable must be complete types"); + }; template struct is_assignable : public is_assignable{}; template struct is_assignable : public is_assignable{}; template struct is_assignable : public is_assignable{}; @@ -57,7 +62,10 @@ namespace boost{ namespace boost{ // We don't know how to implement this: - template struct is_assignable : public integral_constant{}; + template struct is_assignable : public integral_constant + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_assignable must be complete types"); + }; template struct is_assignable : public integral_constant::value && is_pod::type>::value>{}; template struct is_assignable : public integral_constant{}; template struct is_assignable : public integral_constant{}; diff --git a/3rdparty/boost/boost/type_traits/is_complete.hpp b/3rdparty/boost/boost/type_traits/is_complete.hpp new file mode 100644 index 0000000000..cad04b3c9d --- /dev/null +++ b/3rdparty/boost/boost/type_traits/is_complete.hpp @@ -0,0 +1,92 @@ + +// (C) Copyright John Maddock 2017. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_COMPLETE_HPP_INCLUDED +#define BOOST_TT_IS_COMPLETE_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include + +/* + * CAUTION: + * ~~~~~~~~ + * + * THIS TRAIT EXISTS SOLELY TO GENERATE HARD ERRORS WHEN A ANOTHER TRAIT + * WHICH REQUIRES COMPLETE TYPES AS ARGUMENTS IS PASSED AN INCOMPLETE TYPE + * + * DO NOT MAKE GENERAL USE OF THIS TRAIT, AS THE COMPLETENESS OF A TYPE + * VARIES ACROSS TRANSLATION UNITS AS WELL AS WITHIN A SINGLE UNIT. + * +*/ + +namespace boost { + + +// +// We will undef this if the trait isn't fully functional: +// +#define BOOST_TT_HAS_WORKING_IS_COMPLETE + +#if !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40600) + + namespace detail{ + + template + struct ok_tag { double d; char c[N]; }; + + template + ok_tag check_is_complete(int); + template + char check_is_complete(...); + } + + template struct is_complete + : public integral_constant::type>::value || (sizeof(detail::check_is_complete(0)) != sizeof(char))> {}; + +#elif !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) + + namespace detail + { + + template + struct is_complete_imp + { + template ())) > + static type_traits::yes_type check(U*); + + template + static type_traits::no_type check(...); + + static const bool value = sizeof(check(0)) == sizeof(type_traits::yes_type); + }; + +} // namespace detail + + + template + struct is_complete : boost::integral_constant::type>::value || ::boost::detail::is_complete_imp::value> + {}; + template + struct is_complete : boost::is_complete {}; + +#else + + template struct is_complete + : public boost::integral_constant {}; + +#undef BOOST_TT_HAS_WORKING_IS_COMPLETE + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_COMPLETE_HPP_INCLUDED diff --git a/3rdparty/boost/boost/type_traits/is_constructible.hpp b/3rdparty/boost/boost/type_traits/is_constructible.hpp index 20173172ce..da6259948b 100644 --- a/3rdparty/boost/boost/type_traits/is_constructible.hpp +++ b/3rdparty/boost/boost/type_traits/is_constructible.hpp @@ -18,6 +18,10 @@ #include #include #include +#include +#include + +#define BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING 1 namespace boost{ @@ -43,8 +47,14 @@ namespace boost{ } - template struct is_constructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)>{}; - template struct is_constructible : public integral_constant::value && sizeof(detail::is_constructible_imp::test1(0)) == sizeof(boost::type_traits::yes_type)>{}; + template struct is_constructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(::boost::is_complete::value, "The target type must be complete in order to test for constructibility"); + }; + template struct is_constructible : public integral_constant::value && sizeof(detail::is_constructible_imp::test1(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(::boost::is_complete::value, "The target type must be complete in order to test for constructibility"); + }; template struct is_constructible : public integral_constant(boost::declval())) == sizeof(boost::type_traits::yes_type)>{}; template struct is_constructible : public integral_constant(boost::declval())) == sizeof(boost::type_traits::yes_type)>{}; diff --git a/3rdparty/boost/boost/type_traits/is_convertible.hpp b/3rdparty/boost/boost/type_traits/is_convertible.hpp index 417ece20b4..bf648fc46e 100644 --- a/3rdparty/boost/boost/type_traits/is_convertible.hpp +++ b/3rdparty/boost/boost/type_traits/is_convertible.hpp @@ -14,6 +14,10 @@ #include #include +#include +#include +#include +#include #ifndef BOOST_IS_CONVERTIBLE #include #include @@ -474,12 +478,26 @@ template struct is_convertible_impl_dispatch : } // namespace detail template -struct is_convertible : public integral_constant::value> {}; +struct is_convertible : public integral_constant::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value, "Destination argument type to is_convertible must be a complete type"); + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value, "From argument type to is_convertible must be a complete type"); +}; #else template -struct is_convertible : public integral_constant {}; +struct is_convertible : public integral_constant +{ +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1900) + 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__) + // clang's intrinsic doesn't assert on incomplete types: + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value, "Destination argument type to is_convertible must be a complete type"); + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value, "From argument type to is_convertible must be a complete type"); +#endif +}; #endif diff --git a/3rdparty/boost/boost/type_traits/is_default_constructible.hpp b/3rdparty/boost/boost/type_traits/is_default_constructible.hpp index fa5d76a22d..9a4a0a78b2 100644 --- a/3rdparty/boost/boost/type_traits/is_default_constructible.hpp +++ b/3rdparty/boost/boost/type_traits/is_default_constructible.hpp @@ -12,10 +12,15 @@ #include // size_t #include #include +#include +#include #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) #include #endif +#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5)) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1800)) +#include // std::pair +#endif #if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) @@ -48,13 +53,22 @@ namespace boost{ } #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) - template struct is_default_constructible : public integral_constant::value>::value>{}; + template struct is_default_constructible : public integral_constant::value>::value> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_default_constructible must be complete types"); + }; #else - template struct is_default_constructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)>{}; + template struct is_default_constructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_default_constructible must be complete types"); + }; #endif template struct is_default_constructible : public is_default_constructible{}; template struct is_default_constructible : public is_default_constructible{}; template struct is_default_constructible : public integral_constant{}; +#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5))|| (defined(BOOST_MSVC) && (BOOST_MSVC == 1800)) + template struct is_default_constructible > : public integral_constant::value && is_default_constructible::value>{}; +#endif #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) template struct is_default_constructible : public integral_constant{}; #endif diff --git a/3rdparty/boost/boost/type_traits/is_destructible.hpp b/3rdparty/boost/boost/type_traits/is_destructible.hpp index 742d990730..cc72fb7a9a 100644 --- a/3rdparty/boost/boost/type_traits/is_destructible.hpp +++ b/3rdparty/boost/boost/type_traits/is_destructible.hpp @@ -12,6 +12,8 @@ #include // size_t #include #include +#include +#include #if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) @@ -32,7 +34,10 @@ namespace boost{ } - template struct is_destructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)>{}; + template struct is_destructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_destructible must be complete types"); + }; #else @@ -42,7 +47,10 @@ namespace boost{ namespace boost{ // We don't know how to implement this: - template struct is_destructible : public integral_constant::value || is_class::value>{}; + template struct is_destructible : public integral_constant::value || is_class::value> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_destructible must be complete types"); + }; #endif template <> struct is_destructible : public false_type{}; diff --git a/3rdparty/boost/boost/type_traits/is_nothrow_move_assignable.hpp b/3rdparty/boost/boost/type_traits/is_nothrow_move_assignable.hpp index 4fb5bd8a6d..5f63cb7be6 100644 --- a/3rdparty/boost/boost/type_traits/is_nothrow_move_assignable.hpp +++ b/3rdparty/boost/boost/type_traits/is_nothrow_move_assignable.hpp @@ -18,13 +18,18 @@ #include #include #include +#include +#include namespace boost { #ifdef BOOST_IS_NOTHROW_MOVE_ASSIGN template -struct is_nothrow_move_assignable : public integral_constant{}; +struct is_nothrow_move_assignable : public integral_constant +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_assignable must be complete types"); +}; template struct is_nothrow_move_assignable : public false_type{}; template struct is_nothrow_move_assignable : public false_type{}; template struct is_nothrow_move_assignable : public false_type{}; @@ -50,7 +55,10 @@ struct false_or_cpp11_noexcept_move_assignable < } template -struct is_nothrow_move_assignable : public integral_constant::value>{}; +struct is_nothrow_move_assignable : public integral_constant::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_assignable must be complete types"); +}; template struct is_nothrow_move_assignable : public ::boost::false_type {}; template struct is_nothrow_move_assignable : public ::boost::false_type{}; @@ -64,7 +72,10 @@ template struct is_nothrow_move_assignable : public ::boost::fals template struct is_nothrow_move_assignable : public integral_constant::value || ::boost::has_nothrow_assign::value) && ! ::boost::is_array::value>{}; + (::boost::has_trivial_move_assign::value || ::boost::has_nothrow_assign::value) && ! ::boost::is_array::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_assignable must be complete types"); +}; #endif diff --git a/3rdparty/boost/boost/type_traits/is_nothrow_move_constructible.hpp b/3rdparty/boost/boost/type_traits/is_nothrow_move_constructible.hpp index 0d5d57a0f8..30b6a16ec8 100644 --- a/3rdparty/boost/boost/type_traits/is_nothrow_move_constructible.hpp +++ b/3rdparty/boost/boost/type_traits/is_nothrow_move_constructible.hpp @@ -16,18 +16,23 @@ #include #include #include +#include +#include #ifdef BOOST_IS_NOTHROW_MOVE_CONSTRUCT namespace boost { template -struct is_nothrow_move_constructible : public integral_constant{}; +struct is_nothrow_move_constructible : public integral_constant +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_constructible must be complete types"); +}; template struct is_nothrow_move_constructible : public ::boost::false_type {}; template struct is_nothrow_move_constructible : public ::boost::false_type{}; -#elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800) +#elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) #include #include @@ -47,7 +52,10 @@ struct false_or_cpp11_noexcept_move_constructible < } template struct is_nothrow_move_constructible - : public integral_constant::value>{}; + : public integral_constant::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_constructible must be complete types"); +}; template struct is_nothrow_move_constructible : public ::boost::false_type {}; template struct is_nothrow_move_constructible : public ::boost::false_type{}; @@ -66,7 +74,9 @@ template struct is_nothrow_move_constructible : public integral_constant::value || ::boost::has_nothrow_copy::value) && !::boost::is_array::value> -{}; +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_constructible must be complete types"); +}; #endif diff --git a/3rdparty/boost/boost/type_traits/make_void.hpp b/3rdparty/boost/boost/type_traits/make_void.hpp new file mode 100644 index 0000000000..f48823b059 --- /dev/null +++ b/3rdparty/boost/boost/type_traits/make_void.hpp @@ -0,0 +1,52 @@ +/* +Copyright 2017 Glen Joseph 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_TT_MAKE_VOID_HPP_INCLUDED +#define BOOST_TT_MAKE_VOID_HPP_INCLUDED + +#include + +namespace boost { + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +template +struct make_void { + typedef void type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template +using void_t = typename make_void::type; +#endif + +#else /* BOOST_NO_CXX11_VARIADIC_TEMPLATES */ + +template +struct make_void { + typedef void type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template +using void_t = typename make_void::type; +#endif + +#endif + +} /* boost */ + +#endif diff --git a/3rdparty/boost/boost/type_traits/remove_pointer.hpp b/3rdparty/boost/boost/type_traits/remove_pointer.hpp index a7baa765f0..ce32f186ae 100644 --- a/3rdparty/boost/boost/type_traits/remove_pointer.hpp +++ b/3rdparty/boost/boost/type_traits/remove_pointer.hpp @@ -10,6 +10,7 @@ #define BOOST_TT_REMOVE_POINTER_HPP_INCLUDED #include +#include #if defined(BOOST_MSVC) #include diff --git a/3rdparty/boost/boost/type_traits/type_identity.hpp b/3rdparty/boost/boost/type_traits/type_identity.hpp new file mode 100644 index 0000000000..4a03a13a39 --- /dev/null +++ b/3rdparty/boost/boost/type_traits/type_identity.hpp @@ -0,0 +1,31 @@ +#ifndef BOOST_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_TYPE_IDENTITY_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 + +namespace boost +{ + +template struct type_identity +{ + typedef T type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + +template using type_identity_t = typename type_identity::type; + +#endif + + +} // namespace boost + +#endif // #ifndef BOOST_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED diff --git a/3rdparty/boost/boost/type_traits/type_with_alignment.hpp b/3rdparty/boost/boost/type_traits/type_with_alignment.hpp index ddf1d98294..8da5123189 100644 --- a/3rdparty/boost/boost/type_traits/type_with_alignment.hpp +++ b/3rdparty/boost/boost/type_traits/type_with_alignment.hpp @@ -25,9 +25,8 @@ #endif namespace boost { - namespace detail{ - #ifndef __BORLANDC__ + namespace detail{ union max_align { @@ -76,7 +75,7 @@ template struct short_alignment{ typedef typ template struct char_alignment{ typedef char type; }; template struct char_alignment{ typedef typename short_alignment::value >= Target>::type type; }; -} +} // namespace detail template struct type_with_alignment diff --git a/3rdparty/boost/boost/utility.hpp b/3rdparty/boost/boost/utility.hpp index 0aacb8bc36..5ac9ecbd85 100644 --- a/3rdparty/boost/boost/utility.hpp +++ b/3rdparty/boost/boost/utility.hpp @@ -9,13 +9,16 @@ #ifndef BOOST_UTILITY_HPP #define BOOST_UTILITY_HPP -#include +// Use of this header is discouraged and it will be deprecated. +// Please include one or more of the headers below instead. + #include #include -#include #include + +#include +#include #include #include -#include #endif // BOOST_UTILITY_HPP diff --git a/3rdparty/boost/boost/utility/detail/result_of_iterate.hpp b/3rdparty/boost/boost/utility/detail/result_of_iterate.hpp index 5192172cfc..d6538447b1 100644 --- a/3rdparty/boost/boost/utility/detail/result_of_iterate.hpp +++ b/3rdparty/boost/boost/utility/detail/result_of_iterate.hpp @@ -25,16 +25,16 @@ #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) template struct tr1_result_of - : mpl::if_< - mpl::or_< is_pointer, is_member_function_pointer > + : conditional< + is_pointer::value || is_member_function_pointer::value , boost::detail::tr1_result_of_impl< typename remove_cv::type, typename remove_cv::type(BOOST_RESULT_OF_ARGS), - (boost::detail::has_result_type::value)> + (boost::detail::result_of_has_result_type::value)> , boost::detail::tr1_result_of_impl< F, F(BOOST_RESULT_OF_ARGS), - (boost::detail::has_result_type::value)> >::type { }; + (boost::detail::result_of_has_result_type::value)> >::type { }; #endif #ifdef BOOST_RESULT_OF_USE_DECLTYPE @@ -46,7 +46,7 @@ struct result_of #ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK template struct result_of - : mpl::if_, detail::has_result >, + : conditional::value || detail::result_of_has_result::value, tr1_result_of, detail::cpp0x_result_of >::type { }; #endif // BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK @@ -57,8 +57,8 @@ namespace detail { template struct cpp0x_result_of - : mpl::if_< - is_member_function_pointer + : conditional< + is_member_function_pointer::value , detail::tr1_result_of_impl< typename remove_cv::type, typename remove_cv::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false @@ -82,25 +82,22 @@ struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION()) -struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION()); - -template -struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION()) +struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION()) : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION()) {}; template -struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION()) +struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION()) : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION()) {}; template struct BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION()) - : mpl::eval_if< - is_class::type>, + : conditional< + is_class::type>::value, result_of_wrap_callable_class, - mpl::identity::type> > - > + type_identity::type>::type> > + >::type {}; template @@ -111,7 +108,7 @@ struct BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION()) { (boost::declval()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval() BOOST_PP_INTERCEPT)), result_of_weird_type()) )) ); - typedef mpl::bool_ type; + typedef integral_constant type; }; template diff --git a/3rdparty/boost/boost/utility/result_of.hpp b/3rdparty/boost/boost/utility/result_of.hpp index cb16d099b6..2b652ba0ca 100644 --- a/3rdparty/boost/boost/utility/result_of.hpp +++ b/3rdparty/boost/boost/utility/result_of.hpp @@ -18,19 +18,16 @@ #include #include #include -#include -#include -#include -#include -#include -#include #include #include #include #include #include -#include -#include +#include +#include +#include +#include +#include #ifndef BOOST_RESULT_OF_NUM_ARGS # define BOOST_RESULT_OF_NUM_ARGS 16 @@ -47,10 +44,6 @@ BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK cannot be defined at the same time. #endif -#if defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK) && defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE) -# error Cannot fallback to decltype if BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE is not defined. -#endif - #ifndef BOOST_RESULT_OF_USE_TR1 # ifndef BOOST_RESULT_OF_USE_DECLTYPE # ifndef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK @@ -71,11 +64,40 @@ template struct tr1_result_of; // a TR1-style implementation of resu #if !defined(BOOST_NO_SFINAE) namespace detail { -BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type) +typedef char result_of_yes_type; // sizeof(result_of_yes_type) == 1 +typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type) == 2 + +template struct result_of_has_type {}; + +template struct result_of_has_result_type_impl +{ + template static result_of_yes_type f( result_of_has_type* ); + template static result_of_no_type f( ... ); + + typedef boost::integral_constant(0)) == sizeof(result_of_yes_type)> type; +}; + +template struct result_of_has_result_type: result_of_has_result_type_impl::type +{ +}; // Work around a nvcc bug by only defining has_result when it's needed. #ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK -BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result) + +template class C> struct result_of_has_template {}; + +template struct result_of_has_result_impl +{ + template static result_of_yes_type f( result_of_has_template* ); + template static result_of_no_type f( ... ); + + typedef boost::integral_constant(0)) == sizeof(result_of_yes_type)> type; +}; + +template struct result_of_has_result: result_of_has_result_impl::type +{ +}; + #endif template struct tr1_result_of_impl; @@ -97,9 +119,6 @@ struct result_of_weird_type { friend result_of_private_type operator,(result_of_private_type, result_of_weird_type); }; -typedef char result_of_yes_type; // sizeof(result_of_yes_type) == 1 -typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type) == 2 - template result_of_no_type result_of_is_private_type(T const &); result_of_yes_type result_of_is_private_type(result_of_private_type); @@ -180,10 +199,10 @@ struct tr1_result_of_impl }; template -struct is_function_with_no_args : mpl::false_ {}; +struct is_function_with_no_args : false_type {}; template -struct is_function_with_no_args : mpl::true_ {}; +struct is_function_with_no_args : true_type {}; template struct result_of_nested_result : F::template result @@ -191,7 +210,7 @@ struct result_of_nested_result : F::template result template struct tr1_result_of_impl - : mpl::if_, + : conditional::value, result_of_void_impl, result_of_nested_result >::type {}; diff --git a/3rdparty/boost/boost/variant/detail/apply_visitor_binary.hpp b/3rdparty/boost/boost/variant/detail/apply_visitor_binary.hpp index 6670cd8d27..e4abf88d72 100644 --- a/3rdparty/boost/boost/variant/detail/apply_visitor_binary.hpp +++ b/3rdparty/boost/boost/variant/detail/apply_visitor_binary.hpp @@ -4,7 +4,7 @@ //----------------------------------------------------------------------------- // // Copyright (c) 2002-2003 Eric Friedman -// Copyright (c) 2014 Antony Polukhin +// Copyright (c) 2014-2017 Antony Polukhin // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at @@ -19,17 +19,24 @@ #include -#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302)) #include + +#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302)) #include #include #endif - #if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) # include #endif +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +# include +# include +# include +# include +#endif + namespace boost { ////////////////////////////////////////////////////////////////////////// @@ -42,7 +49,7 @@ namespace boost { namespace detail { namespace variant { -template +template class apply_visitor_binary_invoke { public: // visitor typedefs @@ -65,6 +72,24 @@ public: // structors public: // visitor interfaces +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + + template + typename enable_if_c::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type + operator()(Value2&& value2) + { + return visitor_(::boost::move(value1_), ::boost::forward(value2)); + } + + template + typename disable_if_c::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type + operator()(Value2&& value2) + { + return visitor_(value1_, ::boost::forward(value2)); + } + +#else + template BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(Value2& value2) @@ -72,11 +97,13 @@ public: // visitor interfaces return visitor_(value1_, value2); } +#endif + private: apply_visitor_binary_invoke& operator=(const apply_visitor_binary_invoke&); }; -template +template class apply_visitor_binary_unwrap { public: // visitor typedefs @@ -99,6 +126,36 @@ public: // structors public: // visitor interfaces +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + + template + typename enable_if_c::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type + operator()(Value1&& value1) + { + apply_visitor_binary_invoke< + Visitor + , Value1 + , ! ::boost::is_lvalue_reference::value + > invoker(visitor_, value1); + + return boost::apply_visitor(invoker, ::boost::move(visitable2_)); + } + + template + typename disable_if_c::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type + operator()(Value1&& value1) + { + apply_visitor_binary_invoke< + Visitor + , Value1 + , ! ::boost::is_lvalue_reference::value + > invoker(visitor_, value1); + + return boost::apply_visitor(invoker, visitable2_); + } + +#else + template BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(Value1& value1) @@ -106,11 +163,14 @@ public: // visitor interfaces apply_visitor_binary_invoke< Visitor , Value1 + , false > invoker(visitor_, value1); return boost::apply_visitor(invoker, visitable2_); } +#endif + private: apply_visitor_binary_unwrap& operator=(const apply_visitor_binary_unwrap&); @@ -139,44 +199,76 @@ private: #endif // EDG-based compilers workaround +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +template +inline + BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor) +apply_visitor( Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2) +{ + ::boost::detail::variant::apply_visitor_binary_unwrap< + Visitor, Visitable2, ! ::boost::is_lvalue_reference::value + > unwrapper(visitor, visitable2); + + return boost::apply_visitor(unwrapper, ::boost::forward(visitable1)); +} + +#else + template inline BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor) -apply_visitor( - Visitor& visitor - , Visitable1& visitable1, Visitable2& visitable2 - ) +apply_visitor( Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2) { ::boost::detail::variant::apply_visitor_binary_unwrap< - Visitor, Visitable2 + Visitor, Visitable2, false > unwrapper(visitor, visitable2); return boost::apply_visitor(unwrapper, visitable1); } +#endif + #undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE // // const-visitor version: // +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + template inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( typename Visitor::result_type ) -apply_visitor( - const Visitor& visitor - , Visitable1& visitable1, Visitable2& visitable2 - ) +apply_visitor( const Visitor& visitor , Visitable1&& visitable1 , Visitable2&& visitable2) { ::boost::detail::variant::apply_visitor_binary_unwrap< - const Visitor, Visitable2 + const Visitor, Visitable2, ! ::boost::is_lvalue_reference::value + > unwrapper(visitor, visitable2); + + return boost::apply_visitor(unwrapper, ::boost::forward(visitable1)); +} + +#else + +template +inline + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( + typename Visitor::result_type + ) +apply_visitor( const Visitor& visitor , Visitable1& visitable1 , Visitable2& visitable2) +{ + ::boost::detail::variant::apply_visitor_binary_unwrap< + const Visitor, Visitable2, false > unwrapper(visitor, visitable2); return boost::apply_visitor(unwrapper, visitable1); } +#endif + #if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) @@ -188,7 +280,7 @@ apply_visitor( namespace detail { namespace variant { -template +template class apply_visitor_binary_invoke_cpp14 { Visitor& visitor_; @@ -205,16 +297,22 @@ public: // structors public: // visitor interfaces template - decltype(auto) operator()(Value2& value2) + decltype(auto) operator()(Value2&& value2, typename enable_if_c::value>::type* = 0) { - return visitor_(value1_, value2); + return visitor_(::boost::move(value1_), ::boost::forward(value2)); + } + + template + decltype(auto) operator()(Value2&& value2, typename disable_if_c::value>::type* = 0) + { + return visitor_(value1_, ::boost::forward(value2)); } private: apply_visitor_binary_invoke_cpp14& operator=(const apply_visitor_binary_invoke_cpp14&); }; -template +template class apply_visitor_binary_unwrap_cpp14 { Visitor& visitor_; @@ -231,11 +329,24 @@ public: // structors public: // visitor interfaces template - decltype(auto) operator()(Value1& value1) + decltype(auto) operator()(Value1&& value1, typename enable_if_c::value>::type* = 0) { apply_visitor_binary_invoke_cpp14< Visitor , Value1 + , ! ::boost::is_lvalue_reference::value + > invoker(visitor_, value1); + + return boost::apply_visitor(invoker, ::boost::move(visitable2_)); + } + + template + decltype(auto) operator()(Value1&& value1, typename disable_if_c::value>::type* = 0) + { + apply_visitor_binary_invoke_cpp14< + Visitor + , Value1 + , ! ::boost::is_lvalue_reference::value > invoker(visitor_, value1); return boost::apply_visitor(invoker, visitable2_); @@ -248,31 +359,32 @@ private: }} // namespace detail::variant template -inline decltype(auto) apply_visitor(Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2, +inline decltype(auto) apply_visitor(Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2, typename boost::disable_if< boost::detail::variant::has_result_type >::type* = 0) { ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14< - Visitor, Visitable2 + Visitor, Visitable2, ! ::boost::is_lvalue_reference::value > unwrapper(visitor, visitable2); - return boost::apply_visitor(unwrapper, visitable1); + return boost::apply_visitor(unwrapper, ::boost::forward(visitable1)); } template -inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2, +inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2, typename boost::disable_if< boost::detail::variant::has_result_type >::type* = 0) { ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14< - const Visitor, Visitable2 + const Visitor, Visitable2, ! ::boost::is_lvalue_reference::value > unwrapper(visitor, visitable2); - return boost::apply_visitor(unwrapper, visitable1); + return boost::apply_visitor(unwrapper, ::boost::forward(visitable1)); } + #endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) } // namespace boost diff --git a/3rdparty/boost/boost/variant/detail/apply_visitor_unary.hpp b/3rdparty/boost/boost/variant/detail/apply_visitor_unary.hpp index d4e2c166dc..7e93a51415 100644 --- a/3rdparty/boost/boost/variant/detail/apply_visitor_unary.hpp +++ b/3rdparty/boost/boost/variant/detail/apply_visitor_unary.hpp @@ -16,11 +16,13 @@ #include #include #include +#include #if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302)) #include #include #include +#include #endif #if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) @@ -62,6 +64,15 @@ namespace boost { #endif // EDG-based compilers workaround +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +inline + BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor) +apply_visitor(Visitor& visitor, Visitable&& visitable) +{ + return ::boost::forward(visitable).apply_visitor(visitor); +} +#else template inline BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor) @@ -69,6 +80,7 @@ apply_visitor(Visitor& visitor, Visitable& visitable) { return visitable.apply_visitor(visitor); } +#endif #undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE @@ -76,6 +88,15 @@ apply_visitor(Visitor& visitor, Visitable& visitable) // const-visitor version: // +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +inline + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) +apply_visitor(const Visitor& visitor, Visitable&& visitable) +{ + return ::boost::forward(visitable).apply_visitor(visitor); +} +#else template inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type) @@ -83,6 +104,7 @@ apply_visitor(const Visitor& visitor, Visitable& visitable) { return visitable.apply_visitor(visitor); } +#endif #if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) @@ -133,37 +155,27 @@ struct result_wrapper1 { typedef decltype(result_multideduce1::deduce()) result_type; - Visitor& visitor_; - explicit result_wrapper1(Visitor& visitor) BOOST_NOEXCEPT - : visitor_(visitor) + Visitor&& visitor_; + explicit result_wrapper1(Visitor&& visitor) BOOST_NOEXCEPT + : visitor_(::boost::forward(visitor)) {} template - result_type operator()(T& val) const { - return visitor_(val); + result_type operator()(T&& val) const { + return visitor_(::boost::forward(val)); } }; }} // namespace detail::variant template -inline decltype(auto) apply_visitor(Visitor& visitor, Visitable& visitable, - typename boost::disable_if< - boost::detail::variant::has_result_type - >::type* = 0) -{ - boost::detail::variant::result_wrapper1 cpp14_vis(visitor); - return visitable.apply_visitor(cpp14_vis); -} - -template -inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable& visitable, +inline decltype(auto) apply_visitor(Visitor&& visitor, Visitable&& visitable, typename boost::disable_if< boost::detail::variant::has_result_type >::type* = 0) { - boost::detail::variant::result_wrapper1 cpp14_vis(visitor); - return visitable.apply_visitor(cpp14_vis); + boost::detail::variant::result_wrapper1::type> cpp14_vis(::boost::forward(visitor)); + return ::boost::forward(visitable).apply_visitor(cpp14_vis); } #endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) diff --git a/3rdparty/boost/boost/variant/variant.hpp b/3rdparty/boost/boost/variant/variant.hpp index c3e2ccf8e5..d33a23e477 100644 --- a/3rdparty/boost/boost/variant/variant.hpp +++ b/3rdparty/boost/boost/variant/variant.hpp @@ -40,7 +40,7 @@ #include #include #include -#include +#include #include #include #include @@ -145,7 +145,7 @@ struct add_alignment template struct apply : mpl::size_t< - ::boost::math::static_lcm< + ::boost::integer::static_lcm< BOOST_MPL_AUX_VALUE_WKND(State)::value , ::boost::alignment_of::value >::value @@ -1019,7 +1019,7 @@ struct less_comp // * for wrappers (e.g., recursive_wrapper), the wrapper's held value. // * for all other values, the value itself. // -template +template class invoke_visitor { private: // representation @@ -1042,6 +1042,24 @@ public: // structors public: // internal visitor interfaces +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + + //using workaround with is_same to prenvent compilation error, because we need to use T in enable_if to make SFINAE work + template + typename enable_if_c::value, result_type>::type internal_visit(T&& operand, int) + { + return visitor_(::boost::move(operand)); + } + + //using workaround with is_same to prenvent compilation error, because we need to use T in enable_if to make SFINAE work + template + typename disable_if_c::value, result_type>::type internal_visit(T&& operand, int) + { + return visitor_(operand); + } + +#else + template result_type internal_visit(T& operand, int) { @@ -1054,12 +1072,52 @@ public: // internal visitor interfaces { return visitor_(operand); } -# endif +# endif //BORLAND + +#endif //RVALUE REFERENCES #else // defined(BOOST_NO_VOID_RETURNS) private: // helpers, for internal visitor interfaces (below) +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + + //using workaround with is_same to prenvent compilation error, because we need to use T in enable_if to make SFINAE work + template + typename enable_if::value>, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type + visit_impl(T&& operand, mpl::false_) + { + return visitor_(::boost::move(operand)); + } + + //using workaround with is_same to prenvent compilation error, because we need to use T in enable_if to make SFINAE work + template + typename enable_if_c::value, BOOST_VARIANT_AUX_RETURN_VOID_TYPE>::type + visit_impl(T&& operand, mpl::true_) + { + visitor_(::boost::move(operand)); + BOOST_VARIANT_AUX_RETURN_VOID; + } + + //using workaround with is_same to prenvent compilation error, because we need to use T in enable_if to make SFINAE work + template + typename disable_if_c::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type + visit_impl(T&& operand, mpl::false_) + { + return visitor_(operand); + } + + //using workaround with is_same to prenvent compilation error, because we need to use T in enable_if to make SFINAE work + template + typename disable_if::value, BOOST_VARIANT_AUX_RETURN_VOID_TYPE>::type + visit_impl(T&& operand, mpl::true_) + { + visitor_(operand); + BOOST_VARIANT_AUX_RETURN_VOID; + } + +#else + template BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) visit_impl(T& operand, mpl::false_) @@ -1075,6 +1133,8 @@ private: // helpers, for internal visitor interfaces (below) BOOST_VARIANT_AUX_RETURN_VOID; } +#endif //RVALUE_REFERENCES + public: // internal visitor interfaces template @@ -2421,13 +2481,40 @@ public: public: // visitation support +#ifndef BOOST_NO_CXX11_REF_QUALIFIERS + + template + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( + typename Visitor::result_type + ) + apply_visitor(Visitor& visitor) && + { + detail::variant::invoke_visitor invoker(visitor); + return this->internal_apply_visitor(invoker); + } + + template + BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( + typename Visitor::result_type + ) + apply_visitor(Visitor& visitor) const&& + { + detail::variant::invoke_visitor invoker(visitor); + return this->internal_apply_visitor(invoker); + } + +#endif + template BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE( typename Visitor::result_type ) apply_visitor(Visitor& visitor) +#ifndef BOOST_NO_CXX11_REF_QUALIFIERS + & +#endif { - detail::variant::invoke_visitor invoker(visitor); + detail::variant::invoke_visitor invoker(visitor); return this->internal_apply_visitor(invoker); } @@ -2436,8 +2523,11 @@ public: // visitation support typename Visitor::result_type ) apply_visitor(Visitor& visitor) const +#ifndef BOOST_NO_CXX11_REF_QUALIFIERS + & +#endif { - detail::variant::invoke_visitor invoker(visitor); + detail::variant::invoke_visitor invoker(visitor); return this->internal_apply_visitor(invoker); } diff --git a/3rdparty/boost/boost/version.hpp b/3rdparty/boost/boost/version.hpp index 53de342e96..967ff28548 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 106501 +#define BOOST_VERSION 106800 // // 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_65_1" +#define BOOST_LIB_VERSION "1_68" #endif -- 2.39.5