passenger 6.0.16 → 6.0.18

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/implementation.hpp

@@ -47,6 +47,7 @@
 #include <boost/type_traits/make_void.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/unordered/detail/fca.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
 #include <boost/unordered/detail/fwd.hpp>
 #include <boost/utility/addressof.hpp>
 #include <boost/utility/enable_if.hpp>
@@ -181,18 +182,6 @@
 #endif
 #endif
 
-// BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
-
-#if !defined(BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES)
-#if BOOST_COMP_CLANG && __cplusplus >= 201703
-#define BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES 1
-#endif
-#endif
-
-#if !defined(BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES)
-#define BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES 0
-#endif
-
 namespace boost {
   namespace unordered {
     namespace detail {
@@ -200,7 +189,7 @@ namespace boost {
       template <typename Types> struct table;
 
       static const float minimum_max_load_factor = 1e-3f;
-      static const std::size_t default_bucket_count = 11;
+      static const std::size_t default_bucket_count = 0;
 
       struct move_tag
       {
@@ -618,39 +607,6 @@ namespace boost {
 
 #endif
 
-////////////////////////////////////////////////////////////////////////////
-// Type checkers used for the transparent member functions added by C++20 and up
-
-      template <class, class = void> struct is_transparent : public false_type
-      {
-      };
-
-      template <class T>
-      struct is_transparent<T,
-        typename boost::make_void<typename T::is_transparent>::type>
-          : public true_type
-      {
-      };
-
-      template <class, class A, class B> struct are_transparent
-      {
-        static bool const value =
-          is_transparent<A>::value && is_transparent<B>::value;
-      };
-
-      template <class Key, class UnorderedMap> struct transparent_non_iterable
-      {
-        typedef typename UnorderedMap::hasher hash;
-        typedef typename UnorderedMap::key_equal key_equal;
-        typedef typename UnorderedMap::iterator iterator;
-        typedef typename UnorderedMap::const_iterator const_iterator;
-
-        static bool const value =
-          are_transparent<Key, hash, key_equal>::value &&
-          !boost::is_convertible<Key, iterator>::value &&
-          !boost::is_convertible<Key, const_iterator>::value;
-      };
-
 ////////////////////////////////////////////////////////////////////////////
 // Explicitly call a destructor
 
@@ -2054,12 +2010,14 @@ namespace boost {
 
         std::size_t bucket_size(std::size_t index) const
         {
-          bucket_iterator itb = buckets_.at(index);
-          node_pointer n = itb->next;
           std::size_t count = 0;
-          while (n) {
-            ++count;
-            n = n->next;
+          if (size_ > 0) {
+            bucket_iterator itb = buckets_.at(index);
+            node_pointer n = itb->next;
+            while (n) {
+              ++count;
+              n = n->next;
+            }
           }
           return count;
         }
@@ -2069,13 +2027,18 @@ namespace boost {
 
         void recalculate_max_load()
         {
-          using namespace std;
-
           // From 6.3.1/13:
           // Only resize when size >= mlf_ * count
-          max_load_ = boost::unordered::detail::double_to_size(
-            floor(static_cast<double>(mlf_) *
-                 static_cast<double>(buckets_.bucket_count())));
+          std::size_t const bc = buckets_.bucket_count();
+
+          // it's important we do the `bc == 0` check here because the `mlf_`
+          // can be specified to be infinity. The operation `n * INF` is `INF`
+          // for all `n > 0` but NaN for `n == 0`.
+          //
+          max_load_ =
+            bc == 0 ? 0
+                    : boost::unordered::detail::double_to_size(
+                        static_cast<double>(mlf_) * static_cast<double>(bc));
         }
 
         void max_load_factor(float z)
@@ -2088,6 +2051,12 @@ namespace boost {
         ////////////////////////////////////////////////////////////////////////
         // Constructors
 
+        table()
+            : functions(hasher(), key_equal()), size_(0), mlf_(1.0f),
+              max_load_(0)
+        {
+        }
+
         table(std::size_t num_buckets, hasher const& hf, key_equal const& eq,
           node_allocator_type const& a)
             : functions(hf, eq), size_(0), mlf_(1.0f), max_load_(0),
@@ -2359,7 +2328,6 @@ namespace boost {
         template <typename UniqueType>
         void move_assign(table& x, UniqueType is_unique, false_type)
         {
-          reserve(x.size_);
           if (node_alloc() == x.node_alloc()) {
             move_assign_equal_alloc(x);
           } else {
@@ -2388,7 +2356,9 @@ namespace boost {
           {
             mlf_ = x.mlf_;
             recalculate_max_load();
-            this->reserve_for_insert(x.size_);
+            if (x.size_ > 0) {
+              this->reserve_for_insert(x.size_);
+            }
             this->clear_impl();
           }
           BOOST_CATCH(...)
@@ -2420,11 +2390,14 @@ namespace boost {
         node_pointer find_node_impl(
           Key const& x, bucket_iterator itb) const
         {
-          key_equal const& pred = this->key_eq();
-          node_pointer p = itb->next;
-          for (; p; p = p->next) {
-            if (pred(x, extractor::extract(p->value()))) {
-              break;
+          node_pointer p = node_pointer();
+          if (itb != buckets_.end()) {
+            key_equal const& pred = this->key_eq();
+            p = itb->next;
+            for (; p; p = p->next) {
+              if (pred(x, extractor::extract(p->value()))) {
+                break;
+              }
             }
           }
           return p;
@@ -2453,11 +2426,13 @@ namespace boost {
         inline iterator transparent_find(
           Key const& k, Hash const& h, Pred const& pred) const
         {
-          std::size_t const key_hash = h(k);
-          bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
-          for (node_pointer p = itb->next; p; p = p->next) {
-            if (BOOST_LIKELY(pred(k, extractor::extract(p->value())))) {
-              return iterator(p, itb);
+          if (size_ > 0) {
+            std::size_t const key_hash = h(k);
+            bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
+            for (node_pointer p = itb->next; p; p = p->next) {
+              if (BOOST_LIKELY(pred(k, extractor::extract(p->value())))) {
+                return iterator(p, itb);
+              }
             }
           }
 
@@ -2467,11 +2442,13 @@ namespace boost {
         template <class Key>
         node_pointer* find_prev(Key const& key, bucket_iterator itb)
         {
-          key_equal pred = this->key_eq();
-          for (node_pointer* pp = boost::addressof(itb->next); *pp;
-               pp = boost::addressof((*pp)->next)) {
-            if (pred(key, extractor::extract((*pp)->value()))) {
-              return pp;
+          if (size_ > 0) {
+            key_equal pred = this->key_eq();
+            for (node_pointer* pp = boost::addressof(itb->next); *pp;
+                pp = boost::addressof((*pp)->next)) {
+              if (pred(key, extractor::extract((*pp)->value()))) {
+                return pp;
+              }
             }
           }
           typedef node_pointer* node_pointer_pointer;
@@ -2503,6 +2480,17 @@ namespace boost {
           new_buckets.insert_node(itnewb, p);
         }
 
+        static std::size_t min_buckets(std::size_t num_elements, float mlf)
+        {
+          std::size_t num_buckets = static_cast<std::size_t>(
+            std::ceil(static_cast<float>(num_elements) / mlf));
+
+          if (num_buckets == 0 && num_elements > 0) { // mlf == inf
+            num_buckets = 1;
+          }
+          return num_buckets;
+        }
+
         void rehash(std::size_t);
         void reserve(std::size_t);
         void reserve_for_insert(std::size_t);
@@ -3411,22 +3399,18 @@ namespace boost {
       template <typename Types>
       inline void table<Types>::rehash(std::size_t num_buckets)
       {
-        std::size_t bc = (std::max)(num_buckets,
-          static_cast<std::size_t>(1.0f + static_cast<float>(size_) / mlf_));
+        num_buckets = buckets_.bucket_count_for(
+          (std::max)(min_buckets(size_, mlf_), num_buckets));
 
-        if (bc <= buckets_.bucket_count()) {
-          return;
+        if (num_buckets != this->bucket_count()) {
+          this->rehash_impl(num_buckets);
         }
-
-        this->rehash_impl(bc);
       }
 
       template <class Types>
       inline void table<Types>::reserve(std::size_t num_elements)
       {
-        std::size_t const num_buckets = static_cast<std::size_t>(
-          std::ceil(static_cast<float>(num_elements) / mlf_));
-
+        std::size_t num_buckets = min_buckets(num_elements, mlf_);
         this->rehash(num_buckets);
       }
 

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/prime_fmod.hpp

@@ -117,9 +117,15 @@ namespace boost {
 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
           std::size_t sizes_under_32bit = inv_sizes32_len;
           if (BOOST_LIKELY(size_index < sizes_under_32bit)) {
+#if defined(__MSVC_RUNTIME_CHECKS)
+            return fast_modulo(
+              boost::uint32_t(hash & 0xffffffffu) + boost::uint32_t(hash >> 32),
+              inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
+#else
             return fast_modulo(
               boost::uint32_t(hash) + boost::uint32_t(hash >> 32),
               inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
+#endif
           } else {
             return positions[size_index - sizes_under_32bit](hash);
           }

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

@@ -0,0 +1,109 @@
+// Copyright (C) 2022 Christian Mazakas
+//
+// 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_UNORDERED_DETAIL_TYPE_TRAITS_HPP
+#define BOOST_UNORDERED_DETAIL_TYPE_TRAITS_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/make_void.hpp>
+#include <boost/type_traits/type_identity.hpp>
+
+#if !defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#endif
+
+// BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
+
+#if !defined(BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES)
+#if !defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)
+#define BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES 1
+#endif
+#endif
+
+#if !defined(BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES)
+#define BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES 0
+#endif
+
+namespace boost {
+  namespace unordered {
+    namespace detail {
+      ////////////////////////////////////////////////////////////////////////////
+      // Type checkers used for the transparent member functions added by C++20
+      // and up
+
+      template <class, class = void>
+      struct is_transparent : public boost::false_type
+      {
+      };
+
+      template <class T>
+      struct is_transparent<T,
+        typename boost::make_void<typename T::is_transparent>::type>
+          : public boost::true_type
+      {
+      };
+
+      template <class, class A, class B> struct are_transparent
+      {
+        static bool const value =
+          is_transparent<A>::value && is_transparent<B>::value;
+      };
+
+      template <class Key, class UnorderedMap> struct transparent_non_iterable
+      {
+        typedef typename UnorderedMap::hasher hash;
+        typedef typename UnorderedMap::key_equal key_equal;
+        typedef typename UnorderedMap::iterator iterator;
+        typedef typename UnorderedMap::const_iterator const_iterator;
+
+        static bool const value =
+          are_transparent<Key, hash, key_equal>::value &&
+          !boost::is_convertible<Key, iterator>::value &&
+          !boost::is_convertible<Key, const_iterator>::value;
+      };
+
+#if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
+      // https://eel.is/c++draft/container.requirements#container.alloc.reqmts-34
+      // https://eel.is/c++draft/container.requirements#unord.req.general-243
+
+      template <class InputIterator>
+      constexpr bool const is_input_iterator_v =
+        !boost::is_integral<InputIterator>::value;
+
+      template <class A, class = void> struct is_allocator
+      {
+        constexpr static bool const value = false;
+      };
+
+      template <class A>
+      struct is_allocator<A,
+        boost::void_t<typename A::value_type,
+          decltype(std::declval<A&>().allocate(std::size_t{}))> >
+      {
+        constexpr static bool const value = true;
+      };
+
+      template <class A>
+      constexpr bool const is_allocator_v = is_allocator<A>::value;
+
+      template <class H>
+      constexpr bool const is_hash_v =
+        !boost::is_integral<H>::value && !is_allocator_v<H>;
+
+      template <class P> constexpr bool const is_pred_v = !is_allocator_v<P>;
+#endif
+    } // namespace detail
+  }   // namespace unordered
+} // namespace boost
+
+#endif // BOOST_UNORDERED_DETAIL_TYPE_TRAITS_HPP

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/xmx.hpp

@@ -0,0 +1,75 @@
+/* 32b/64b xmx mix function.
+ *
+ * Copyright 2022 Peter Dimov.
+ * Copyright 2022 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 https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_XMX_HPP
+#define BOOST_UNORDERED_DETAIL_XMX_HPP
+
+#include <boost/cstdint.hpp>
+#include <climits>
+#include <cstddef>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+
+/* Bit mixer for improvement of statistical properties of hash functions.
+ * The implementation is different on 64bit and 32bit architectures:
+ * 
+ *   - 64bit: same as xmx function in
+ *     http://jonkagstrom.com/bit-mixer-construction/index.html
+ *   - 32bit: generated by Hash Function Prospector
+ *     (https://github.com/skeeto/hash-prospector) and selected as the
+ *     best overall performer in benchmarks of Boost.Unordered flat containers.
+ *     Score assigned by Hash Prospector: 333.7934929677524
+ */
+
+#if defined(SIZE_MAX)
+#if ((((SIZE_MAX >> 16) >> 16) >> 16) >> 15) != 0
+#define BOOST_UNORDERED_64B_ARCHITECTURE /* >64 bits assumed as 64 bits */
+#endif
+#elif defined(UINTPTR_MAX) /* used as proxy for std::size_t */
+#if ((((UINTPTR_MAX >> 16) >> 16) >> 16) >> 15) != 0
+#define BOOST_UNORDERED_64B_ARCHITECTURE
+#endif
+#endif
+
+static inline std::size_t xmx(std::size_t x)noexcept
+{
+#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
+
+  boost::uint64_t z=(boost::uint64_t)x;
+
+  z^=z>>23;
+  z*=0xff51afd7ed558ccdull;
+  z^=z>>23;
+
+  return (std::size_t)z;
+
+#else /* 32 bits assumed */
+
+  x^=x>>18;
+  x*=0x56b5aaadu;
+  x^=x>>16;
+
+  return x;
+
+#endif
+}
+
+#ifdef BOOST_UNORDERED_64B_ARCHITECTURE
+#undef BOOST_UNORDERED_64B_ARCHITECTURE
+#endif
+
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/unordered/hash_traits.hpp

@@ -0,0 +1,45 @@
+/* Hash function characterization.
+ *
+ * Copyright 2022 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 https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_HASH_TRAITS_HPP
+#define BOOST_UNORDERED_HASH_TRAITS_HPP
+
+#include <boost/type_traits/make_void.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+namespace boost{
+namespace unordered{
+
+namespace detail{
+
+template<typename Hash,typename=void>
+struct hash_is_avalanching_impl: boost::false_type{};
+
+template<typename Hash>
+struct hash_is_avalanching_impl<Hash,
+  typename boost::make_void<typename Hash::is_avalanching>::type>:
+    boost::true_type{};
+
+} /* namespace detail */
+
+/* Each trait can be partially specialized by users for concrete hash functions
+ * when actual characterization differs from default.
+ */
+
+/* hash_is_avalanching<Hash>::value is true when the type Hash::is_avalanching
+ * is present, false otherwise.
+ */
+template<typename Hash>
+struct hash_is_avalanching: detail::hash_is_avalanching_impl<Hash>::type{};
+
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif