passenger 6.0.20 → 6.0.22

data/src/cxx_supportlib/vendor-modified/boost/container_hash/detail/hash_tuple_like.hpp

@@ -9,17 +9,8 @@
 #include <boost/container_hash/hash_fwd.hpp>
 #include <boost/container_hash/is_tuple_like.hpp>
 #include <boost/container_hash/is_range.hpp>
-#include <boost/type_traits/enable_if.hpp>
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
-
-#if defined(BOOST_NO_CXX11_HDR_TUPLE)
-
-// no support for tuple-likes
-
-#else
-
-#include <tuple>
+#include <type_traits>
+#include <utility>
 
 namespace boost
 {
@@ -28,14 +19,14 @@ namespace hash_detail
 
 template <std::size_t I, typename T>
 inline
-typename boost::enable_if_<(I == std::tuple_size<T>::value), void>::type
+typename std::enable_if<(I == std::tuple_size<T>::value), void>::type
     hash_combine_tuple_like( std::size_t&, T const& )
 {
 }
 
 template <std::size_t I, typename T>
 inline
-typename boost::enable_if_<(I < std::tuple_size<T>::value), void>::type
+typename std::enable_if<(I < std::tuple_size<T>::value), void>::type
     hash_combine_tuple_like( std::size_t& seed, T const& v )
 {
     using std::get;
@@ -56,13 +47,9 @@ inline std::size_t hash_tuple_like( T const& v )
 
 } // namespace hash_detail
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1800)
-
 template <class T>
 inline
-typename boost::enable_if_<
+typename std::enable_if<
     container_hash::is_tuple_like<T>::value && !container_hash::is_range<T>::value,
 std::size_t>::type
     hash_value( T const& v )
@@ -70,87 +57,6 @@ std::size_t>::type
     return boost::hash_detail::hash_tuple_like( v );
 }
 
-#else
-
-template <typename... T>
-inline std::size_t hash_value( std::tuple<T...> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-#endif
-
-#else
-
-inline std::size_t hash_value( std::tuple<> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0>
-inline std::size_t hash_value( std::tuple<A0> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1>
-inline std::size_t hash_value( std::tuple<A0, A1> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1, typename A2>
-inline std::size_t hash_value( std::tuple<A0, A1, A2> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1, typename A2, typename A3>
-inline std::size_t hash_value( std::tuple<A0, A1, A2, A3> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1, typename A2, typename A3, typename A4>
-inline std::size_t hash_value( std::tuple<A0, A1, A2, A3, A4> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-inline std::size_t hash_value( std::tuple<A0, A1, A2, A3, A4, A5> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-inline std::size_t hash_value( std::tuple<A0, A1, A2, A3, A4, A5, A6> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-inline std::size_t hash_value( std::tuple<A0, A1, A2, A3, A4, A5, A6, A7> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-inline std::size_t hash_value( std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-inline std::size_t hash_value( std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-#endif // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
 } // namespace boost
 
-#endif // #if defined(BOOST_NO_CXX11_HDR_TUPLE)
-
 #endif // #ifndef BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP

data/src/cxx_supportlib/vendor-modified/boost/container_hash/detail/mulx.hpp

@@ -5,7 +5,7 @@
 #ifndef BOOST_HASH_DETAIL_MULX_HPP
 #define BOOST_HASH_DETAIL_MULX_HPP
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #if defined(_MSC_VER)
 # include <intrin.h>
 #endif
@@ -17,55 +17,55 @@ namespace hash_detail
 
 #if defined(_MSC_VER) && defined(_M_X64) && !defined(__clang__)
 
-__forceinline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
+__forceinline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
 {
-    boost::uint64_t r2;
-    boost::uint64_t r = _umul128( x, y, &r2 );
+    std::uint64_t r2;
+    std::uint64_t r = _umul128( x, y, &r2 );
     return r ^ r2;
 }
 
 #elif defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__)
 
-__forceinline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
+__forceinline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
 {
-    boost::uint64_t r = x * y;
-    boost::uint64_t r2 = __umulh( x, y );
+    std::uint64_t r = x * y;
+    std::uint64_t r2 = __umulh( x, y );
     return r ^ r2;
 }
 
 #elif defined(__SIZEOF_INT128__)
 
-inline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
+inline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
 {
     __uint128_t r = static_cast<__uint128_t>( x ) * y;
-    return static_cast<boost::uint64_t>( r ) ^ static_cast<boost::uint64_t>( r >> 64 );
+    return static_cast<std::uint64_t>( r ) ^ static_cast<std::uint64_t>( r >> 64 );
 }
 
 #else
 
-inline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
+inline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
 {
-    boost::uint64_t x1 = static_cast<boost::uint32_t>( x );
-    boost::uint64_t x2 = x >> 32;
+    std::uint64_t x1 = static_cast<std::uint32_t>( x );
+    std::uint64_t x2 = x >> 32;
 
-    boost::uint64_t y1 = static_cast<boost::uint32_t>( y );
-    boost::uint64_t y2 = y >> 32;
+    std::uint64_t y1 = static_cast<std::uint32_t>( y );
+    std::uint64_t y2 = y >> 32;
 
-    boost::uint64_t r3 = x2 * y2;
+    std::uint64_t r3 = x2 * y2;
 
-    boost::uint64_t r2a = x1 * y2;
+    std::uint64_t r2a = x1 * y2;
 
     r3 += r2a >> 32;
 
-    boost::uint64_t r2b = x2 * y1;
+    std::uint64_t r2b = x2 * y1;
 
     r3 += r2b >> 32;
 
-    boost::uint64_t r1 = x1 * y1;
+    std::uint64_t r1 = x1 * y1;
 
-    boost::uint64_t r2 = (r1 >> 32) + static_cast<boost::uint32_t>( r2a ) + static_cast<boost::uint32_t>( r2b );
+    std::uint64_t r2 = (r1 >> 32) + static_cast<std::uint32_t>( r2a ) + static_cast<std::uint32_t>( r2b );
 
-    r1 = (r2 << 32) + static_cast<boost::uint32_t>( r1 );
+    r1 = (r2 << 32) + static_cast<std::uint32_t>( r1 );
     r3 += r2 >> 32;
 
     return r1 ^ r3;

data/src/cxx_supportlib/vendor-modified/boost/container_hash/hash.hpp

@@ -11,27 +11,18 @@
 #define BOOST_FUNCTIONAL_HASH_HASH_HPP
 
 #include <boost/container_hash/hash_fwd.hpp>
-#include <boost/container_hash/detail/requires_cxx11.hpp>
 #include <boost/container_hash/is_range.hpp>
 #include <boost/container_hash/is_contiguous_range.hpp>
 #include <boost/container_hash/is_unordered_range.hpp>
 #include <boost/container_hash/is_described_class.hpp>
+#include <boost/container_hash/detail/hash_integral.hpp>
 #include <boost/container_hash/detail/hash_tuple_like.hpp>
 #include <boost/container_hash/detail/hash_mix.hpp>
 #include <boost/container_hash/detail/hash_range.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_unsigned.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/enable_if.hpp>
-#include <boost/type_traits/conjunction.hpp>
-#include <boost/type_traits/is_union.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <boost/describe/bases.hpp>
 #include <boost/describe/members.hpp>
-#include <boost/cstdint.hpp>
+#include <type_traits>
+#include <cstdint>
 
 #if defined(BOOST_DESCRIBE_CXX14)
 # include <boost/mp11/algorithm.hpp>
@@ -77,95 +68,12 @@ namespace boost
     //
 
     // integral types
-
-    namespace hash_detail
-    {
-        template<class T,
-            bool bigger_than_size_t = (sizeof(T) > sizeof(std::size_t)),
-            bool is_unsigned = boost::is_unsigned<T>::value,
-            std::size_t size_t_bits = sizeof(std::size_t) * CHAR_BIT,
-            std::size_t type_bits = sizeof(T) * CHAR_BIT>
-        struct hash_integral_impl;
-
-        template<class T, bool is_unsigned, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, false, is_unsigned, size_t_bits, type_bits>
-        {
-            static std::size_t fn( T v )
-            {
-                return static_cast<std::size_t>( v );
-            }
-        };
-
-        template<class T, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, true, false, size_t_bits, type_bits>
-        {
-            static std::size_t fn( T v )
-            {
-                typedef typename boost::make_unsigned<T>::type U;
-
-                if( v >= 0 )
-                {
-                    return hash_integral_impl<U>::fn( static_cast<U>( v ) );
-                }
-                else
-                {
-                    return ~hash_integral_impl<U>::fn( static_cast<U>( ~static_cast<U>( v ) ) );
-                }
-            }
-        };
-
-        template<class T> struct hash_integral_impl<T, true, true, 32, 64>
-        {
-            static std::size_t fn( T v )
-            {
-                std::size_t seed = 0;
-
-                seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
-                seed = static_cast<std::size_t>( v  & 0xFFFFFFFF ) + hash_detail::hash_mix( seed );
-
-                return seed;
-            }
-        };
-
-        template<class T> struct hash_integral_impl<T, true, true, 32, 128>
-        {
-            static std::size_t fn( T v )
-            {
-                std::size_t seed = 0;
-
-                seed = static_cast<std::size_t>( v >> 96 ) + hash_detail::hash_mix( seed );
-                seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
-                seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
-                seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
-
-                return seed;
-            }
-        };
-
-        template<class T> struct hash_integral_impl<T, true, true, 64, 128>
-        {
-            static std::size_t fn( T v )
-            {
-                std::size_t seed = 0;
-
-                seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
-                seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
-
-                return seed;
-            }
-        };
-
-    } // namespace hash_detail
-
-    template <typename T>
-    typename boost::enable_if_<boost::is_integral<T>::value, std::size_t>::type
-        hash_value( T v )
-    {
-        return hash_detail::hash_integral_impl<T>::fn( v );
-    }
+    //   in detail/hash_integral.hpp
 
     // enumeration types
 
     template <typename T>
-    typename boost::enable_if_<boost::is_enum<T>::value, std::size_t>::type
+    typename std::enable_if<std::is_enum<T>::value, std::size_t>::type
         hash_value( T v )
     {
         // This should in principle return the equivalent of
@@ -199,7 +107,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint32_t w;
+                std::uint32_t w;
                 std::memcpy( &w, &v, sizeof( v ) );
 
                 return w;
@@ -211,7 +119,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint64_t w;
+                std::uint64_t w;
                 std::memcpy( &w, &v, sizeof( v ) );
 
                 return hash_value( w );
@@ -223,7 +131,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint64_t w[ 2 ] = {};
+                std::uint64_t w[ 2 ] = {};
                 std::memcpy( &w, &v, 80 / CHAR_BIT );
 
                 std::size_t seed = 0;
@@ -240,7 +148,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint64_t w[ 2 ] = {};
+                std::uint64_t w[ 2 ] = {};
                 std::memcpy( &w, &v, 80 / CHAR_BIT );
 
                 std::size_t seed = 0;
@@ -257,7 +165,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint64_t w[ 2 ];
+                std::uint64_t w[ 2 ];
                 std::memcpy( &w, &v, sizeof( v ) );
 
                 std::size_t seed = 0;
@@ -280,7 +188,7 @@ namespace boost
     } // namespace hash_detail
 
     template <typename T>
-    typename boost::enable_if_<boost::is_floating_point<T>::value, std::size_t>::type
+    typename std::enable_if<std::is_floating_point<T>::value, std::size_t>::type
         hash_value( T v )
     {
         return boost::hash_detail::hash_float_impl<T>::fn( v + 0 );
@@ -291,7 +199,7 @@ namespace boost
     // `x + (x >> 3)` adjustment by Alberto Barbati and Dave Harris.
     template <class T> std::size_t hash_value( T* const& v )
     {
-        boost::uintptr_t x = reinterpret_cast<boost::uintptr_t>( v );
+        std::uintptr_t x = reinterpret_cast<std::uintptr_t>( v );
         return boost::hash_value( x + (x >> 3) );
     }
 
@@ -336,7 +244,7 @@ namespace boost
     // ranges (list, set, deque...)
 
     template <typename T>
-    typename boost::enable_if_<container_hash::is_range<T>::value && !container_hash::is_contiguous_range<T>::value && !container_hash::is_unordered_range<T>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_range<T>::value && !container_hash::is_contiguous_range<T>::value && !container_hash::is_unordered_range<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
         return boost::hash_range( v.begin(), v.end() );
@@ -345,7 +253,7 @@ namespace boost
     // contiguous ranges (string, vector, array)
 
     template <typename T>
-    typename boost::enable_if_<container_hash::is_contiguous_range<T>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_contiguous_range<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
         return boost::hash_range( v.data(), v.data() + v.size() );
@@ -354,7 +262,7 @@ namespace boost
     // unordered ranges (unordered_set, unordered_map)
 
     template <typename T>
-    typename boost::enable_if_<container_hash::is_unordered_range<T>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_unordered_range<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
         return boost::hash_unordered_range( v.begin(), v.end() );
@@ -367,7 +275,7 @@ namespace boost
     // resolve ambiguity with unconstrained stdext::hash_value in <xhash> :-/
 
     template<template<class...> class L, class... T>
-    typename boost::enable_if_<container_hash::is_range<L<T...>>::value && !container_hash::is_contiguous_range<L<T...>>::value && !container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_range<L<T...>>::value && !container_hash::is_contiguous_range<L<T...>>::value && !container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
         hash_value( L<T...> const& v )
     {
         return boost::hash_range( v.begin(), v.end() );
@@ -376,14 +284,14 @@ namespace boost
     // contiguous ranges (string, vector, array)
 
     template<template<class...> class L, class... T>
-    typename boost::enable_if_<container_hash::is_contiguous_range<L<T...>>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_contiguous_range<L<T...>>::value, std::size_t>::type
         hash_value( L<T...> const& v )
     {
         return boost::hash_range( v.data(), v.data() + v.size() );
     }
 
     template<template<class, std::size_t> class L, class T, std::size_t N>
-    typename boost::enable_if_<container_hash::is_contiguous_range<L<T, N>>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_contiguous_range<L<T, N>>::value, std::size_t>::type
         hash_value( L<T, N> const& v )
     {
         return boost::hash_range( v.data(), v.data() + v.size() );
@@ -392,7 +300,7 @@ namespace boost
     // unordered ranges (unordered_set, unordered_map)
 
     template<template<class...> class L, class... T>
-    typename boost::enable_if_<container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
         hash_value( L<T...> const& v )
     {
         return boost::hash_unordered_range( v.begin(), v.end() );
@@ -410,10 +318,10 @@ namespace boost
 #endif
 
     template <typename T>
-    typename boost::enable_if_<container_hash::is_described_class<T>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_described_class<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
-        static_assert( !boost::is_union<T>::value, "described unions are not supported" );
+        static_assert( !std::is_union<T>::value, "described unions are not supported" );
 
         std::size_t r = 0;
 
@@ -503,7 +411,7 @@ namespace boost
 #if !defined(BOOST_NO_CXX11_NULLPTR)
 
     template <typename T>
-    typename boost::enable_if_<boost::is_same<T, std::nullptr_t>::value, std::size_t>::type
+    typename std::enable_if<std::is_same<T, std::nullptr_t>::value, std::size_t>::type
         hash_value( T const& /*v*/ )
     {
         return boost::hash_value( static_cast<void*>( nullptr ) );
@@ -520,7 +428,7 @@ namespace boost
     {
         if( !v )
         {
-            // Arbitray value for empty optional.
+            // Arbitrary value for empty optional.
             return 0x12345678;
         }
         else
@@ -654,20 +562,11 @@ namespace boost
     namespace unordered
     {
         template<class T> struct hash_is_avalanching;
-        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: boost::is_integral<Ch> {};
-
-        // boost::is_integral<char8_t> is false, but should be true (https://github.com/boostorg/type_traits/issues/175)
-#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
-        template<> struct hash_is_avalanching< boost::hash< std::basic_string<char8_t> > >: boost::true_type {};
-#endif
+        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: std::is_integral<Ch> {};
 
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 
-        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: boost::is_integral<Ch> {};
-
-#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
-        template<> struct hash_is_avalanching< boost::hash< std::basic_string_view<char8_t> > >: boost::true_type {};
-#endif
+        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: std::is_integral<Ch> {};
 
 #endif
     } // namespace unordered

data/src/cxx_supportlib/vendor-modified/boost/container_hash/is_contiguous_range.hpp

@@ -5,17 +5,13 @@
 #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
 #define BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
 
-#include <boost/container_hash/detail/requires_cxx11.hpp>
 #include <boost/container_hash/is_range.hpp>
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
+#include <type_traits>
 
-#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700) && !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/declval.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <iterator>
 
 namespace boost
@@ -24,11 +20,11 @@ namespace hash_detail
 {
 
 template<class It, class T, class S>
-    integral_constant< bool, is_same<typename std::iterator_traits<It>::value_type, T>::value && is_integral<S>::value >
+    std::integral_constant< bool, std::is_same<typename std::iterator_traits<It>::value_type, T>::value && std::is_integral<S>::value >
         is_contiguous_range_check( It first, It last, T const*, T const*, S );
 
-template<class T> decltype( is_contiguous_range_check( declval<T const&>().begin(), declval<T const&>().end(), declval<T const&>().data(), declval<T const&>().data() + declval<T const&>().size(), declval<T const&>().size() ) ) is_contiguous_range_( int );
-template<class T> false_type is_contiguous_range_( ... );
+template<class T> decltype( is_contiguous_range_check( std::declval<T const&>().begin(), std::declval<T const&>().end(), std::declval<T const&>().data(), std::declval<T const&>().data() + std::declval<T const&>().size(), std::declval<T const&>().size() ) ) is_contiguous_range_( int );
+template<class T> std::false_type is_contiguous_range_( ... );
 
 template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguous_range_<T>( 0 ) )
 {
@@ -39,54 +35,64 @@ template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguo
 namespace container_hash
 {
 
-template<class T> struct is_contiguous_range: integral_constant< bool, is_range<T>::value && hash_detail::is_contiguous_range<T>::value >
+template<class T> struct is_contiguous_range: std::integral_constant< bool, is_range<T>::value && hash_detail::is_contiguous_range<T>::value >
 {
 };
 
 } // namespace container_hash
 } // namespace boost
 
-#else // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
+#else // !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 
 #include <cstddef>
 #include <vector>
 #include <string>
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
 #include <array>
-#endif
 
 namespace boost
 {
 namespace container_hash
 {
 
-template<class T> struct is_contiguous_range: false_type
+template<class T> struct is_contiguous_range: std::false_type
 {
 };
 
-template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> >: true_type
+template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> >: std::true_type
 {
 };
 
-template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> const >: true_type
+template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> const >: std::true_type
 {
 };
 
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+template<class T, class A> struct is_contiguous_range< std::vector<T, A> >: std::true_type
+{
+};
+
+template<class T, class A> struct is_contiguous_range< std::vector<T, A> const >: std::true_type
+{
+};
 
-template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> >: true_type
+template<class A> struct is_contiguous_range< std::vector<bool, A> >: std::false_type
 {
 };
 
-template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> const >: true_type
+template<class A> struct is_contiguous_range< std::vector<bool, A> const >: std::false_type
 {
 };
 
-#endif
+template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> >: std::true_type
+{
+};
+
+template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> const >: std::true_type
+{
+};
 
 } // namespace container_hash
 } // namespace boost
 
-#endif // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 
 #endif // #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/container_hash/is_described_class.hpp

@@ -5,10 +5,9 @@
 #ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
 #define BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
 
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_union.hpp>
 #include <boost/describe/bases.hpp>
 #include <boost/describe/members.hpp>
+#include <type_traits>
 
 namespace boost
 {
@@ -17,16 +16,16 @@ namespace container_hash
 
 #if defined(BOOST_DESCRIBE_CXX11)
 
-template<class T> struct is_described_class: boost::integral_constant<bool,
+template<class T> struct is_described_class: std::integral_constant<bool,
     describe::has_describe_bases<T>::value &&
     describe::has_describe_members<T>::value &&
-    !boost::is_union<T>::value>
+    !std::is_union<T>::value>
 {
 };
 
 #else
 
-template<class T> struct is_described_class: boost::false_type
+template<class T> struct is_described_class: std::false_type
 {
 };