passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp

@@ -67,7 +67,7 @@ template <class R, class T >
 struct is_mem_fun_pointer_impl<R(T::*)(...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T >
 struct is_mem_fun_pointer_impl<R(T::*)()noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -113,7 +113,7 @@ template <class R, class T, class T0>
 struct is_mem_fun_pointer_impl<R(T::*)(T0 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0>
 struct is_mem_fun_pointer_impl<R(T::*)(T0)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -159,7 +159,7 @@ template <class R, class T, class T0, class T1>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -205,7 +205,7 @@ template <class R, class T, class T0, class T1, class T2>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -251,7 +251,7 @@ template <class R, class T, class T0, class T1, class T2, class T3>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -297,7 +297,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -343,7 +343,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -389,7 +389,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -435,7 +435,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -481,7 +481,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -527,7 +527,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -573,7 +573,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -619,7 +619,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -665,7 +665,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -711,7 +711,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -757,7 +757,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -803,7 +803,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -849,7 +849,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -895,7 +895,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -941,7 +941,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -987,7 +987,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -1033,7 +1033,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -1079,7 +1079,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -1125,7 +1125,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -1171,7 +1171,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -1217,7 +1217,7 @@ template <class R, class T, class T0, class T1, class T2, class T3, class T4, cl
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const volatile> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #endif
 #endif
-#if __cpp_noexcept_function_type
+#ifdef __cpp_noexcept_function_type
 template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
 struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
@@ -1290,7 +1290,7 @@ struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)
 @#endif
 @#endif
 
-@#if __cpp_noexcept_function_type
+@#ifdef __cpp_noexcept_function_type
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, class T)>
 struct is_mem_fun_pointer_impl<R(T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER, T))noexcept> { BOOST_STATIC_CONSTANT(bool, value = true); };

data/src/cxx_supportlib/vendor-modified/boost/type_traits/detail/is_swappable_cxx_11.hpp

@@ -0,0 +1,70 @@
+#ifndef BOOST_TYPE_TRAITS_DETAIL_IS_SWAPPABLE_CXX_11_HPP_INCLUDED
+#define BOOST_TYPE_TRAITS_DETAIL_IS_SWAPPABLE_CXX_11_HPP_INCLUDED
+
+//  Copyright 2017 Peter Dimov
+//  Copyright 2023 Andrey Semashev
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <boost/type_traits/declval.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#if __cplusplus >= 201103L || defined(BOOST_DINKUMWARE_STDLIB)
+#include <utility> // for std::swap (C++11)
+#else
+#include <algorithm> // for std::swap (C++98)
+#endif
+
+// Intentionally not within boost namespace to avoid implicitly pulling in boost::swap overloads other than through ADL
+namespace boost_type_traits_swappable_detail
+{
+
+using std::swap;
+
+template<class T, class U, class = decltype(swap(boost::declval<T>(), boost::declval<U>()))> boost::true_type is_swappable_with_impl( int );
+template<class T, class U> boost::false_type is_swappable_with_impl( ... );
+template<class T, class U>
+struct is_swappable_with_helper { typedef decltype( boost_type_traits_swappable_detail::is_swappable_with_impl<T, U>(0) ) type; };
+
+template<class T, class = decltype(swap(boost::declval<T&>(), boost::declval<T&>()))> boost::true_type is_swappable_impl( int );
+template<class T> boost::false_type is_swappable_impl( ... );
+template<class T>
+struct is_swappable_helper { typedef decltype( boost_type_traits_swappable_detail::is_swappable_impl<T>(0) ) type; };
+
+#if !defined(BOOST_NO_CXX11_NOEXCEPT)
+
+#if BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
+// gcc 4.6 ICEs when noexcept operator is used on an invalid expression
+template<class T, class U, bool = is_swappable_with_helper<T, U>::type::value>
+struct is_nothrow_swappable_with_helper { typedef boost::false_type type; };
+template<class T, class U>
+struct is_nothrow_swappable_with_helper<T, U, true> { typedef boost::integral_constant<bool, noexcept(swap(boost::declval<T>(), boost::declval<U>()))> type; };
+
+template<class T, bool = is_swappable_helper<T>::type::value>
+struct is_nothrow_swappable_helper { typedef boost::false_type type; };
+template<class T>
+struct is_nothrow_swappable_helper<T, true> { typedef boost::integral_constant<bool, noexcept(swap(boost::declval<T&>(), boost::declval<T&>()))> type; };
+
+#else // BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
+template<class T, class U, bool B = noexcept(swap(boost::declval<T>(), boost::declval<U>()))> boost::integral_constant<bool, B> is_nothrow_swappable_with_impl( int );
+template<class T, class U> boost::false_type is_nothrow_swappable_with_impl( ... );
+template<class T, class U>
+struct is_nothrow_swappable_with_helper { typedef decltype( boost_type_traits_swappable_detail::is_nothrow_swappable_with_impl<T, U>(0) ) type; };
+
+template<class T, bool B = noexcept(swap(boost::declval<T&>(), boost::declval<T&>()))> boost::integral_constant<bool, B> is_nothrow_swappable_impl( int );
+template<class T> boost::false_type is_nothrow_swappable_impl( ... );
+template<class T>
+struct is_nothrow_swappable_helper { typedef decltype( boost_type_traits_swappable_detail::is_nothrow_swappable_impl<T>(0) ) type; };
+
+#endif // BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
+#endif // !defined(BOOST_NO_CXX11_NOEXCEPT)
+
+} // namespace boost_type_traits_swappable_detail
+
+#endif // #ifndef BOOST_TYPE_TRAITS_DETAIL_IS_SWAPPABLE_CXX_11_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/type_traits/intrinsics.hpp

@@ -160,7 +160,7 @@
 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
 #endif
 
-#if defined(BOOST_CLANG) && defined(__has_feature) && !defined(__CUDACC__)
+#if defined(BOOST_CLANG) && defined(__has_feature) && defined(__has_builtin) && (!(defined(__CUDACC__) && (__CUDACC_VER_MAJOR__ < 11)) || defined(__CUDA__))
 //
 // Note that these intrinsics are disabled for the CUDA meta-compiler as it appears
 // to not support them, even though the underlying clang compiler does so.
@@ -183,25 +183,39 @@
 #   if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty)
 #     define BOOST_IS_EMPTY(T) __is_empty(T)
 #   endif
-#   if __has_feature(has_trivial_constructor)
+#   if __has_builtin(__is_trivially_constructible)
+#     define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __is_trivially_constructible(T)
+#   elif __has_feature(has_trivial_constructor)
 #     define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
 #   endif
-#   if __has_feature(has_trivial_copy)
+#   if __has_builtin(__is_trivially_copyable)
+#     define BOOST_HAS_TRIVIAL_COPY(T) (__is_trivially_copyable(T) && !is_reference<T>::value)
+#   elif __has_feature(has_trivial_copy)
 #     define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value)
 #   endif
-#   if __has_feature(has_trivial_assign)
+#   if __has_builtin(__is_trivially_assignable)
+#     define BOOST_HAS_TRIVIAL_ASSIGN(T) (__is_trivially_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
+#   elif __has_feature(has_trivial_assign)
 #     define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
 #   endif
-#   if __has_feature(has_trivial_destructor)
+#   if __has_builtin(__is_trivially_destructible)
+#     define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__is_trivially_destructible(T)  && is_destructible<T>::value)
+#   elif __has_feature(has_trivial_destructor)
 #     define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T)  && is_destructible<T>::value)
 #   endif
-#   if __has_feature(has_nothrow_constructor)
+#   if __has_builtin(__is_nothrow_constructible)
+#     define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__is_nothrow_constructible(T) && is_default_constructible<T>::value)
+#   elif __has_feature(has_nothrow_constructor)
 #     define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) && is_default_constructible<T>::value)
 #   endif
-#   if __has_feature(has_nothrow_copy)
+#   if __has_builtin(__is_nothrow_constructible)
+#     define BOOST_HAS_NOTHROW_COPY(T) (__is_nothrow_constructible(T, const T&) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
+#   elif __has_feature(has_nothrow_copy)
 #     define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
 #   endif
-#   if __has_feature(has_nothrow_assign)
+#   if __has_builtin(__is_nothrow_assignable)
+#     define BOOST_HAS_NOTHROW_ASSIGN(T) (__is_nothrow_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
+#   elif __has_feature(has_nothrow_assign)
 #     define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)
 #   endif
 #   if __has_feature(has_virtual_destructor)

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_complete.hpp

@@ -15,6 +15,7 @@
 #include <boost/type_traits/is_function.hpp>
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/config/workaround.hpp>
+#include <cstddef>
 
 /*
  * CAUTION:
@@ -40,7 +41,7 @@ namespace boost {
 
    namespace detail{
 
-      template <unsigned N>
+      template <std::size_t N>
       struct ok_tag { double d; char c[N]; };
 
       template <class T>

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_floating_point.hpp

@@ -10,6 +10,10 @@
 
 #include <boost/type_traits/integral_constant.hpp>
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#include <stdfloat>
+#endif
+
 namespace boost {
 
 //* is a type T a floating-point type described in the standard (3.9.1p8)
@@ -25,6 +29,24 @@ namespace boost {
    template<> struct is_floating_point<__float128> : public true_type{};
 #endif
 
+#ifndef BOOST_NO_CXX23_HDR_STDFLOAT
+#if defined(__STDCPP_FLOAT16_T__)
+   template<> struct is_floating_point<std::float16_t> : public true_type {};
+#endif
+#if defined(__STDCPP_FLOAT32_T__)
+   template<> struct is_floating_point<std::float32_t> : public true_type {};
+#endif
+#if defined(__STDCPP_FLOAT64_T__)
+   template<> struct is_floating_point<std::float64_t> : public true_type {};
+#endif
+#if defined(__STDCPP_FLOAT128_T__)
+   template<> struct is_floating_point<std::float128_t> : public true_type {};
+#endif
+#if defined(__STDCPP_BFLOAT16_T__)
+   template<> struct is_floating_point<std::bfloat16_t> : public true_type {};
+#endif
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_function.hpp

@@ -14,7 +14,7 @@
 #include <boost/type_traits/detail/config.hpp>
 #include <boost/config/workaround.hpp>
 
-#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION
+#ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION
 
 #include <boost/type_traits/detail/is_function_cxx_11.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_integral.hpp

@@ -81,6 +81,9 @@ template<> struct is_integral<char16_t> : public true_type{};
 #ifndef BOOST_NO_CXX11_CHAR32_T
 template<> struct is_integral<char32_t> : public true_type{};
 #endif
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+template<> struct is_integral<char8_t> : public true_type{};
+#endif
 
 #endif  // non-CodeGear implementation
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_member_function_pointer.hpp

@@ -13,7 +13,7 @@
 
 #include <boost/type_traits/detail/config.hpp>
 
-#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION
+#ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION
 
 #include <boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_nothrow_swappable.hpp

@@ -8,10 +8,9 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 
 #if defined(BOOST_NO_SFINAE_EXPR) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DECLTYPE) \
-   || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
+   || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
 
 #include <boost/type_traits/is_scalar.hpp>
 #include <boost/type_traits/is_const.hpp>
@@ -28,35 +27,16 @@ template <class T> struct is_nothrow_swappable_with<T, T> : is_nothrow_swappable
 
 #else
 
-#include <boost/type_traits/declval.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <algorithm>
+#include <boost/type_traits/detail/is_swappable_cxx_11.hpp>
 
 namespace boost
 {
 
-namespace type_traits_swappable_detail
-{
-
-using std::swap;
-
-template<class T, class U, bool B = noexcept(swap(declval<T>(), declval<U>()))> integral_constant<bool, B> is_nothrow_swappable_with_impl( int );
-template<class T, class U> false_type is_nothrow_swappable_with_impl( ... );
-template<class T, class U>
-struct is_nothrow_swappable_with_helper { typedef decltype( type_traits_swappable_detail::is_nothrow_swappable_with_impl<T, U>(0) ) type; };
-
-template<class T, bool B = noexcept(swap(declval<T&>(), declval<T&>()))> integral_constant<bool, B> is_nothrow_swappable_impl( int );
-template<class T> false_type is_nothrow_swappable_impl( ... );
-template<class T>
-struct is_nothrow_swappable_helper { typedef decltype( type_traits_swappable_detail::is_nothrow_swappable_impl<T>(0) ) type; };
-
-} // namespace type_traits_swappable_detail
-
-template<class T, class U> struct is_nothrow_swappable_with: type_traits_swappable_detail::is_nothrow_swappable_with_helper<T, U>::type
+template<class T, class U> struct is_nothrow_swappable_with: boost_type_traits_swappable_detail::is_nothrow_swappable_with_helper<T, U>::type
 {
 };
 
-template<class T> struct is_nothrow_swappable: type_traits_swappable_detail::is_nothrow_swappable_helper<T>::type
+template<class T> struct is_nothrow_swappable: boost_type_traits_swappable_detail::is_nothrow_swappable_helper<T>::type
 {
 };
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_swappable.hpp

@@ -0,0 +1,92 @@
+#ifndef BOOST_TYPE_TRAITS_IS_SWAPPABLE_HPP_INCLUDED
+#define BOOST_TYPE_TRAITS_IS_SWAPPABLE_HPP_INCLUDED
+
+//  Copyright 2023 Andrey Semashev
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && \
+    !(defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_CXX_VERSION < 201703L))
+
+#include <boost/type_traits/detail/is_swappable_cxx_11.hpp>
+
+namespace boost
+{
+
+template<class T, class U> struct is_swappable_with : boost_type_traits_swappable_detail::is_swappable_with_helper<T, U>::type
+{
+};
+
+template<class T> struct is_swappable : boost_type_traits_swappable_detail::is_swappable_helper<T>::type
+{
+};
+
+} // namespace boost
+
+#elif defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_CXX_VERSION < 201703L) && \
+    !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) // these are required for is_constructible and is_assignable
+
+// MSVC standard library has SFINAE-unfriendly std::swap in C++ modes prior to C++17,
+// so we have to reproduce the restrictions on std::swap that are in effect in C++17 mode.
+
+#include <cstddef>
+#include <boost/type_traits/negation.hpp>
+#include <boost/type_traits/conjunction.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_constructible.hpp>
+#include <boost/type_traits/is_assignable.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/detail/is_swappable_cxx_11.hpp>
+
+namespace boost
+{
+
+template<class T> struct is_swappable
+    : boost::conjunction<
+        boost::negation< boost::is_const<T> >,
+        boost::is_constructible<T, T&&>,
+        boost::is_assignable<T&, T&&>
+    >::type {};
+
+template<> struct is_swappable<void> : false_type {};
+template<> struct is_swappable<const void> : false_type {};
+template<> struct is_swappable<volatile void> : false_type {};
+template<> struct is_swappable<const volatile void> : false_type {};
+template<class T> struct is_swappable<T[]> : false_type {};
+template<class T> struct is_swappable<T(&)[]> : false_type {};
+template<class T, std::size_t N> struct is_swappable<T[N]> : is_swappable<T> {};
+template<class T, std::size_t N> struct is_swappable<T(&)[N]> : is_swappable<T> {};
+
+template<class T, class U> struct is_swappable_with : boost_type_traits_swappable_detail::is_swappable_with_helper<T, U>::type
+{
+};
+
+template<class T> struct is_swappable_with<T, T> : is_swappable<T> {};
+
+} // namespace boost
+
+#else
+
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+namespace boost
+{
+
+template<class T> struct is_swappable : boost::is_scalar<T> {};
+template<class T> struct is_swappable<const T> : false_type {};
+
+template<class T, class U> struct is_swappable_with : false_type {};
+template<class T> struct is_swappable_with<T, T> : is_swappable<T> {};
+
+} // namespace boost
+
+#endif
+
+#endif // #ifndef BOOST_TYPE_TRAITS_IS_SWAPPABLE_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/decltype.hpp

@@ -6,12 +6,11 @@
 #ifndef BOOST_TYPEOF_DECLTYPE_HPP_INCLUDED
 # define BOOST_TYPEOF_DECLTYPE_HPP_INCLUDED
 
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
+#include <type_traits>
 
 namespace boost { namespace type_of {
     template<typename T>
-        using remove_cv_ref_t = typename remove_cv<typename remove_reference<T>::type>::type;
+    using remove_cv_ref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 }}
 
 #define BOOST_TYPEOF(expr) boost::type_of::remove_cv_ref_t<decltype(expr)>

data/src/cxx_supportlib/vendor-modified/boost/typeof/incr_registration_group.hpp

@@ -2,13 +2,4 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
-// Inclusion of this file increments BOOST_TYPEOF_REGISTRATION_GROUP 
-// This method was suggested by Paul Mensonides
-
-#ifdef BOOST_TYPEOF_EMULATION
-#   undef BOOST_TYPEOF_REGISTRATION_GROUP
-
-#   include <boost/preprocessor/slot/counter.hpp>
-#   include BOOST_PP_UPDATE_COUNTER()
-#   define BOOST_TYPEOF_REGISTRATION_GROUP BOOST_PP_COUNTER
-#endif
+// This header is no longer useful and is only retained for compatibility