passenger 6.0.0 → 6.0.5

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

@@ -155,4 +155,9 @@ namespace boost
 #undef BOOST_TT_FORBIDDEN_IF
 
 #endif
+
+#if defined(BOOST_MSVC)
+#   pragma warning (pop)
+#endif
+
 #endif

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

@@ -153,4 +153,9 @@ namespace boost
 #undef BOOST_TT_FORBIDDEN_IF
 
 #endif
+
+#if defined(BOOST_MSVC)
+#   pragma warning (pop)
+#endif
+
 #endif

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

@@ -41,4 +41,25 @@
 #undef BOOST_TT_TRAIT_OP
 #undef BOOST_TT_FORBIDDEN_IF
 
+#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
+
+namespace boost {
+
+   template <class R>
+   struct has_post_decrement<bool, R> : public false_type {};
+   template <>
+   struct has_post_decrement<bool, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_post_decrement<bool, void> : public false_type {};
+
+   template <class R>
+   struct has_post_decrement<bool&, R> : public false_type {};
+   template <>
+   struct has_post_decrement<bool&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_post_decrement<bool&, void> : public false_type {};
+
+}
+
+#endif
 #endif

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

@@ -41,4 +41,25 @@
 #undef BOOST_TT_TRAIT_OP
 #undef BOOST_TT_FORBIDDEN_IF
 
+#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
+
+namespace boost {
+
+   template <class R>
+   struct has_post_increment<bool, R> : public false_type {};
+   template <>
+   struct has_post_increment<bool, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_post_increment<bool, void> : public false_type {};
+
+   template <class R>
+   struct has_post_increment<bool&, R> : public false_type {};
+   template <>
+   struct has_post_increment<bool&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_post_increment<bool&, void> : public false_type {};
+
+}
+
+#endif
 #endif

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

@@ -41,4 +41,25 @@
 #undef BOOST_TT_TRAIT_OP
 #undef BOOST_TT_FORBIDDEN_IF
 
+#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
+
+namespace boost {
+
+   template <class R>
+   struct has_pre_decrement<bool, R> : public false_type {};
+   template <>
+   struct has_pre_decrement<bool, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_pre_decrement<bool, void> : public false_type {};
+
+   template <class R>
+   struct has_pre_decrement<bool&, R> : public false_type {};
+   template <>
+   struct has_pre_decrement<bool&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_pre_decrement<bool&, void> : public false_type {};
+
+}
+
+#endif
 #endif

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

@@ -41,4 +41,26 @@
 #undef BOOST_TT_TRAIT_OP
 #undef BOOST_TT_FORBIDDEN_IF
 
+#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
+
+namespace boost {
+
+   template <class R>
+   struct has_pre_increment<bool, R> : public false_type {};
+   template <>
+   struct has_pre_increment<bool, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_pre_increment<bool, void> : public false_type {};
+
+   template <class R>
+   struct has_pre_increment<bool&, R> : public false_type {};
+   template <>
+   struct has_pre_increment<bool&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_pre_increment<bool&, void> : public false_type {};
+
+}
+
+#endif
+
 #endif

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

@@ -24,7 +24,7 @@
 #endif
 #endif
 
-#if defined(__GNUC__) || defined(__clang)
+#if defined(__GNUC__) || defined(__clang__)
 #include <boost/type_traits/is_assignable.hpp>
 #include <boost/type_traits/is_volatile.hpp>
 #endif

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

@@ -20,9 +20,10 @@
 #if defined(BOOST_MSVC) || defined(BOOST_INTEL)
 #include <boost/type_traits/is_pod.hpp>
 #include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/is_reference.hpp>
 #endif
 
-#if defined(__GNUC__) || defined(__clang)
+#if defined(__GNUC__) || defined(__clang__)
 #include <boost/type_traits/is_constructible.hpp>
 #include <boost/type_traits/is_volatile.hpp>
 #endif

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

@@ -56,17 +56,12 @@ namespace boost{
       typedef T value_type;
       typedef integral_constant<T, val> type;
       static const T value = val;
-      //
-      // This helper function is just to disable type-punning 
-      // warnings from GCC:
-      //
-      template <class U>
-      static U& dereference(U* p) { return *p; }
 
       operator const mpl::integral_c<T, val>& ()const
       {
          static const char data[sizeof(long)] = { 0 };
-         return dereference(reinterpret_cast<const mpl::integral_c<T, val>*>(&data));
+         static const void* pdata = data;
+         return *(reinterpret_cast<const mpl::integral_c<T, val>*>(pdata));
       }
       BOOST_CONSTEXPR operator T()const { return val; }
    };
@@ -81,17 +76,12 @@ namespace boost{
       typedef bool value_type;
       typedef integral_constant<bool, val> type;
       static const bool value = val;
-      //
-      // This helper function is just to disable type-punning 
-      // warnings from GCC:
-      //
-      template <class T>
-      static T& dereference(T* p) { return *p; }
 
       operator const mpl::bool_<val>& ()const
       {
-         static const char data = 0;
-         return dereference(reinterpret_cast<const mpl::bool_<val>*>(&data));
+         static const char data[sizeof(long)] = { 0 };
+         static const void* pdata = data;
+         return *(reinterpret_cast<const mpl::bool_<val>*>(pdata));
       }
       BOOST_CONSTEXPR operator bool()const { return val; }
    };

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

@@ -122,19 +122,25 @@
 //  This one fails if the default alignment has been changed with /Zp:
 //  #   define BOOST_ALIGNMENT_OF(T) __alignof(T)
 
-#   if defined(_MSC_VER) && (_MSC_VER >= 1700)
+#   if defined(_MSC_VER) && (_MSC_VER >= 1800)
+#       define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__is_trivially_constructible(T, T&&) || boost::is_pod<T>::value) && ! ::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
+#       define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__is_trivially_assignable(T, T&&) || boost::is_pod<T>::value) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
+#   elif defined(_MSC_VER) && (_MSC_VER >= 1700)
 #       define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || boost::is_pod<T>::value) && ! ::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
 #       define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || boost::is_pod<T>::value) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
 #   endif
 #ifndef BOOST_NO_CXX11_FINAL
 //  This one doesn't quite always do the right thing on older VC++ versions
-//  we really need it when the final keyword is supporyted though:
+//  we really need it when the final keyword is supported though:
 #   define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
 #endif
 #if _MSC_FULL_VER >= 180020827
 #   define BOOST_IS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&))
 #   define BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) (__is_nothrow_constructible(T, T&&))
 #endif
+#if _MSC_VER >= 1800
+#   define BOOST_IS_FINAL(T) __is_final(T)
+#endif
 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
 #endif
 
@@ -219,12 +225,14 @@
 #   if __has_feature(is_polymorphic)
 #     define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
 #   endif
-#   if __has_feature(has_trivial_move_constructor)
-#     define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T)  && is_constructible<T, T&&>::value && !::boost::is_volatile<T>::value)
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#   if __has_extension(is_trivially_constructible)
+#     define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_trivially_constructible(T, T&&) && is_constructible<T, T&&>::value && !::boost::is_volatile<T>::value)
 #   endif
-#   if __has_feature(has_trivial_move_assign)
-#     define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) && is_assignable<T&, T&&>::value && !::boost::is_volatile<T>::value)
+#   if __has_extension(is_trivially_assignable)
+#     define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_trivially_assignable(T&, T&&) && is_assignable<T&, T&&>::value && !::boost::is_volatile<T>::value)
 #   endif
+#endif
 #   if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) || !defined(__GNUC__)
 // GCC sometimes lies about alignment requirements
 // of type double on 32-bit unix platforms, use the
@@ -266,7 +274,9 @@
 #   define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value)
 #   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS)
 #   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS)
+#if ((__GNUC__ * 100 + __GNUC_MINOR__) != 407) && ((__GNUC__ * 100 + __GNUC_MINOR__) != 408)
 #   define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value && !is_array<T>::value)
+#endif
 #   define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value && !is_array<T>::value)
 #endif
 #   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)

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

@@ -9,9 +9,11 @@
 #ifndef BOOST_TT_IS_COMPLETE_HPP_INCLUDED
 #define BOOST_TT_IS_COMPLETE_HPP_INCLUDED
 
+#include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/config/workaround.hpp>
 
 /*
@@ -58,7 +60,7 @@ namespace boost {
       template <class T>
       struct is_complete_imp
       {
-         template <class U, class = decltype(sizeof(std::declval< U >())) >
+         template <class U, class = decltype(sizeof(boost::declval< U >())) >
          static type_traits::yes_type check(U*);
 
          template <class U>

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

@@ -11,8 +11,7 @@
 
 #include <boost/config.hpp>
 #include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/noncopyable.hpp>
+#include <boost/type_traits/is_noncopyable.hpp>
 
 #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \
    && !defined(BOOST_INTEL_CXX_VERSION) && \
@@ -112,7 +111,7 @@ struct is_copy_assignable_impl {
     typedef BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type unreferenced_t;
     BOOST_STATIC_CONSTANT(bool, value = (
         boost::detail::is_copy_assignable_impl2<
-            boost::is_base_and_derived<boost::noncopyable, T>::value
+            boost::is_noncopyable<T>::value
             || boost::is_const<unreferenced_t>::value || boost::is_array<unreferenced_t>::value
             ,T
         >::value
@@ -120,7 +119,7 @@ struct is_copy_assignable_impl {
     #else
     BOOST_STATIC_CONSTANT(bool, value = (
         boost::detail::is_copy_assignable_impl2<
-            boost::is_base_and_derived<boost::noncopyable, T>::value,T
+            boost::is_noncopyable<T>::value,T
         >::value
     ));
     #endif

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

@@ -37,8 +37,7 @@ template <> struct is_copy_constructible : public false_type{};
 // an incorrect value, which just defers the issue into the users code) as well.  We can at least fix
 // boost::non_copyable as a base class as a special case:
 //
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/noncopyable.hpp>
+#include <boost/type_traits/is_noncopyable.hpp>
 
 namespace boost {
 
@@ -50,7 +49,7 @@ namespace boost {
 
    }
 
-   template <class T> struct is_copy_constructible : public detail::is_copy_constructible_imp<T, is_base_and_derived<boost::noncopyable, T>::value>{};
+   template <class T> struct is_copy_constructible : public detail::is_copy_constructible_imp<T, is_noncopyable<T>::value>{};
 
    template <> struct is_copy_constructible<void> : public false_type{};
    template <> struct is_copy_constructible<void const> : public false_type{};
@@ -64,13 +63,12 @@ namespace boost {
 #else
 
 #include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_noncopyable.hpp>
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/is_rvalue_reference.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/declval.hpp>
-#include <boost/noncopyable.hpp>
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -160,7 +158,7 @@ namespace boost {
 
          BOOST_STATIC_CONSTANT(bool, value = (
             boost::detail::is_copy_constructible_impl2<
-            boost::is_base_and_derived<boost::noncopyable, T>::value,
+            boost::is_noncopyable<T>::value,
             T
             >::value
             ));

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

@@ -1,6 +1,6 @@
 /*
 Copyright 2017-2018 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+(glenjofe@gmail.com)
 
 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt

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

@@ -1,6 +1,6 @@
 /*
 Copyright 2017-2018 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+(glenjofe@gmail.com)
 
 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt

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

@@ -1,6 +1,6 @@
 /*
 Copyright 2017-2018 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+(glenjofe@gmail.com)
 
 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt

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

@@ -20,7 +20,7 @@
 namespace boost {
 
 #ifdef BOOST_IS_FINAL
-template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(typename remove_cv<T>::type)> {};
+template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(T)> {};
 #else
 template <class T> struct is_final : public integral_constant<bool, false> {};
 #endif

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

@@ -11,92 +11,17 @@
 #ifndef BOOST_TT_IS_FUNCTION_HPP_INCLUDED
 #define BOOST_TT_IS_FUNCTION_HPP_INCLUDED
 
-#include <boost/type_traits/is_reference.hpp>
 #include <boost/type_traits/detail/config.hpp>
+#include <boost/config/workaround.hpp>
 
-#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
-#   include <boost/type_traits/detail/is_function_ptr_helper.hpp>
-#else
-#   include <boost/type_traits/detail/is_function_ptr_tester.hpp>
-#   include <boost/type_traits/detail/yes_no_type.hpp>
-#endif
-
-// is a type a function?
-// Please note that this implementation is unnecessarily complex:
-// we could just use !is_convertible<T*, const volatile void*>::value,
-// except that some compilers erroneously allow conversions from
-// function pointers to void*.
-
-namespace boost {
-
-#if !defined( __CODEGEARC__ )
+#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION
 
-namespace detail {
-
-#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
-template<bool is_ref = true>
-struct is_function_chooser
-{
-   template< typename T > struct result_
-      : public false_type {};
-};
-
-template <>
-struct is_function_chooser<false>
-{
-    template< typename T > struct result_
-        : public ::boost::type_traits::is_function_ptr_helper<T*> {};
-};
-
-template <typename T>
-struct is_function_impl
-    : public is_function_chooser< ::boost::is_reference<T>::value >
-        ::BOOST_NESTED_TEMPLATE result_<T>
-{
-};
+#include <boost/type_traits/detail/is_function_cxx_11.hpp>
 
 #else
 
-template <typename T>
-struct is_function_impl
-{
-#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
-#pragma warning(push)
-#pragma warning(disable:6334)
-#endif
-    static T* t;
-    BOOST_STATIC_CONSTANT(
-        bool, value = sizeof(::boost::type_traits::is_function_ptr_tester(t))
-        == sizeof(::boost::type_traits::yes_type)
-        );
-#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
-#pragma warning(pop)
-#endif
-};
-
-template <typename T>
-struct is_function_impl<T&> : public false_type
-{};
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <typename T>
-struct is_function_impl<T&&> : public false_type
-{};
-#endif
-
-#endif
+#include <boost/type_traits/detail/is_function_cxx_03.hpp>
 
-} // namespace detail
-
-#endif // !defined( __CODEGEARC__ )
-
-#if defined( __CODEGEARC__ )
-template <class T> struct is_function : integral_constant<bool, __is_function(T)> {};
-#else
-template <class T> struct is_function : integral_constant<bool, ::boost::detail::is_function_impl<T>::value> {};
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct is_function<T&&> : public false_type {};
-#endif
 #endif
-} // namespace boost
 
 #endif // BOOST_TT_IS_FUNCTION_HPP_INCLUDED