passenger 6.2.1 → 6.2.2

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

@@ -1,7 +1,8 @@
 /* Fast open-addressing, node-based concurrent hashset.
  *
  * Copyright 2023 Christian Mazakas.
- * Copyright 2023-2024 Joaquin M Lopez Munoz.
+ * Copyright 2023-2026 Joaquin M Lopez Munoz.
+ * Copyright 2026 Braden Ganetsky
  * 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)
@@ -18,6 +19,7 @@
 #include <boost/unordered/detail/foa/element_type.hpp>
 #include <boost/unordered/detail/foa/node_set_handle.hpp>
 #include <boost/unordered/detail/foa/node_set_types.hpp>
+#include <boost/unordered/detail/ranges_support.hpp>
 #include <boost/unordered/detail/type_traits.hpp>
 #include <boost/unordered/unordered_node_set_fwd.hpp>
 
@@ -106,6 +108,21 @@ namespace boost {
         this->insert(f, l);
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<
+        detail::convertible_to_from_range_t FromRangeT,
+        detail::container_compatible_range<value_type> R
+      >
+      concurrent_node_set(FromRangeT&&, R&& rg,
+        size_type n = detail::foa::default_bucket_count,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type())
+          : table_(n, hf, eql, a)
+      {
+        this->insert_range(std::forward<R>(rg));
+      }
+#endif
+
       concurrent_node_set(concurrent_node_set const& rhs)
           : table_(rhs.table_,
               boost::allocator_select_on_container_copy_construction(
@@ -125,6 +142,19 @@ namespace boost {
       {
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<
+        detail::convertible_to_from_range_t FromRangeT,
+        detail::container_compatible_range<value_type> R
+      >
+      concurrent_node_set(
+        FromRangeT&& fr, R&& rg, allocator_type const& a)
+          : concurrent_node_set(
+            fr, std::forward<R>(rg), 0, hasher(), key_equal(), a)
+      {
+      }
+#endif
+
       explicit concurrent_node_set(allocator_type const& a)
           : table_(detail::foa::default_bucket_count, hasher(), key_equal(), a)
       {
@@ -175,6 +205,29 @@ namespace boost {
       {
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<
+        detail::convertible_to_from_range_t FromRangeT,
+        detail::container_compatible_range<value_type> R
+      >
+      concurrent_node_set(
+        FromRangeT&& fr, R&& rg, size_type n, const allocator_type& a)
+          : concurrent_node_set(
+            fr, std::forward<R>(rg), n, hasher(), key_equal(), a)
+      {
+      }
+
+      template<
+        detail::convertible_to_from_range_t FromRangeT,
+        detail::container_compatible_range<value_type> R
+      >
+      concurrent_node_set(FromRangeT&& fr, R&& rg, size_type n,
+        const hasher& hf, const allocator_type& a)
+          : concurrent_node_set(fr, std::forward<R>(rg), n, hf, key_equal(), a)
+      {
+      }
+#endif
+
       concurrent_node_set(
         std::initializer_list<value_type> il, const allocator_type& a)
           : concurrent_node_set(
@@ -194,9 +247,10 @@ namespace boost {
       {
       }
 
-      template <bool avoid_explicit_instantiation = true>
+      template <typename Key2,
+        typename std::enable_if<std::is_same<Key, Key2>::value, int>::type = 0>
       concurrent_node_set(
-        unordered_node_set<Key, Hash, Pred, Allocator>&& other)
+        unordered_node_set<Key2, Hash, Pred, Allocator>&& other)
           : table_(std::move(other.table_))
       {
       }
@@ -436,12 +490,26 @@ namespace boost {
       size_type insert(InputIterator begin, InputIterator end)
       {
         size_type count_elements = 0;
-        for (auto pos = begin; pos != end; ++pos, ++count_elements) {
-          table_.emplace(*pos);
+        for (auto pos = begin; pos != end; ++pos) {
+          if (table_.emplace(*pos)) ++count_elements;
         }
         return count_elements;
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<detail::container_compatible_range<value_type> R>
+      size_type insert_range(R&& rg)
+      {
+        size_type count_elements = 0;
+        auto first = std::ranges::begin(rg);
+        auto last = std::ranges::end(rg);
+        while (first != last) {
+          if (table_.emplace(*first++)) ++count_elements;
+        }
+        return count_elements;
+      }
+#endif
+
       size_type insert(std::initializer_list<value_type> ilist)
       {
         return this->insert(ilist.begin(), ilist.end());
@@ -501,6 +569,21 @@ namespace boost {
         return count_elements;
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<detail::container_compatible_range<value_type> R, class F>
+      size_type insert_range_or_visit(R&& rg, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        size_type count_elements = 0;
+        auto first = std::ranges::begin(rg);
+        auto last = std::ranges::end(rg);
+        for (; first != last; ++first, ++count_elements) {
+          table_.emplace_or_visit(*first, f);
+        }
+        return count_elements;
+      }
+#endif
+
       template <class F>
       size_type insert_or_visit(std::initializer_list<value_type> ilist, F f)
       {
@@ -564,6 +647,21 @@ namespace boost {
         return count_elements;
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<detail::container_compatible_range<value_type> R, class F>
+      size_type insert_range_or_cvisit(R&& rg, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        size_type count_elements = 0;
+        auto first = std::ranges::begin(rg);
+        auto last = std::ranges::end(rg);
+        for (; first != last; ++first, ++count_elements) {
+          table_.emplace_or_cvisit(*first, f);
+        }
+        return count_elements;
+      }
+#endif
+
       template <class F>
       size_type insert_or_cvisit(std::initializer_list<value_type> ilist, F f)
       {
@@ -633,6 +731,24 @@ namespace boost {
         return count_elements;
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<
+        detail::container_compatible_range<value_type> R, class F1, class F2
+      >
+      size_type insert_range_and_visit(R&& rg, F1 f1, F2 f2)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
+        size_type count_elements = 0;
+        auto first = std::ranges::begin(rg);
+        auto last = std::ranges::end(rg);
+        for (; first != last; ++first, ++count_elements) {
+          table_.emplace_and_visit(*first, f1, f2);
+        }
+        return count_elements;
+      }
+#endif
+
       template <class F1, class F2>
       size_type insert_and_visit(
         std::initializer_list<value_type> ilist, F1 f1, F2 f2)
@@ -706,6 +822,24 @@ namespace boost {
         return count_elements;
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<
+        detail::container_compatible_range<value_type> R, class F1, class F2
+      >
+      size_type insert_range_and_cvisit(R&& rg, F1 f1, F2 f2)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F1)
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F2)
+        size_type count_elements = 0;
+        auto first = std::ranges::begin(rg);
+        auto last = std::ranges::end(rg);
+        for (; first != last; ++first, ++count_elements) {
+          table_.emplace_and_cvisit(*first, f1, f2);
+        }
+        return count_elements;
+      }
+#endif
+
       template <class F1, class F2>
       size_type insert_and_cvisit(
         std::initializer_list<value_type> ilist, F1 f1, F2 f2)
@@ -1000,6 +1134,26 @@ namespace boost {
         typename std::iterator_traits<InputIterator>::value_type, Hash, Pred,
         Allocator>;
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+    template <
+      boost::unordered::detail::convertible_to_from_range_t FromRangeT,
+      std::ranges::input_range R,
+      class Hash =
+        boost::hash<std::ranges::range_value_t<R> >,
+      class Pred =
+        std::equal_to<std::ranges::range_value_t<R> >,
+      class Allocator = std::allocator<std::ranges::range_value_t<R> >,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_pred_v<Pred> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
+    concurrent_node_set(FromRangeT&&, R&&,
+      std::size_t = boost::unordered::detail::foa::default_bucket_count,
+      Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> concurrent_node_set<std::ranges::range_value_t<R>,
+        Hash, Pred, Allocator>;
+#endif
+
+
     template <class T, class Hash = boost::hash<T>,
       class Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
       class = std::enable_if_t<detail::is_hash_v<Hash> >,
@@ -1041,6 +1195,39 @@ namespace boost {
         std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
         Allocator>;
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+    template <boost::unordered::detail::convertible_to_from_range_t FromRangeT,
+      std::ranges::input_range R,
+      class Allocator,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
+    concurrent_node_set(FromRangeT&&, R&&, std::size_t, Allocator)
+      -> concurrent_node_set<std::ranges::range_value_t<R>,
+        boost::hash<std::ranges::range_value_t<R> >,
+        std::equal_to<std::ranges::range_value_t<R> >,
+        Allocator>;
+
+    template <boost::unordered::detail::convertible_to_from_range_t FromRangeT,
+      std::ranges::input_range R,
+      class Hash, class Allocator,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
+    concurrent_node_set(
+      FromRangeT&&, R&&, std::size_t, Hash, Allocator)
+      -> concurrent_node_set<std::ranges::range_value_t<R>,
+        Hash, std::equal_to<std::ranges::range_value_t<R> >,
+        Allocator>;
+
+    template <boost::unordered::detail::convertible_to_from_range_t FromRangeT,
+      std::ranges::input_range R,
+      class Allocator,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
+    concurrent_node_set(FromRangeT&&, R&&, Allocator)
+      -> concurrent_node_set<std::ranges::range_value_t<R>,
+        boost::hash<std::ranges::range_value_t<R> >,
+        std::equal_to<std::ranges::range_value_t<R> >,
+        Allocator>;
+#endif
+
     template <class T, class Allocator,
       class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     concurrent_node_set(std::initializer_list<T>, std::size_t, Allocator)

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

@@ -1,6 +1,6 @@
 /* Fast open-addressing concurrent hash table.
  *
- * Copyright 2023-2024 Joaquin M Lopez Munoz.
+ * Copyright 2023-2026 Joaquin M Lopez Munoz.
  * Copyright 2024 Braden Ganetsky.
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or copy at
@@ -697,9 +697,9 @@ public:
   }
 
   /* Optimizations for maps for (k,v) to avoid eagerly constructing value */
-  template <typename K, typename V>
+  template <typename K, typename V, typename Table = concurrent_table>
   BOOST_FORCEINLINE auto emplace(K&& k, V&& v) ->
-    typename std::enable_if<is_emplace_kv_able<concurrent_table, K>::value,
+    typename std::enable_if<is_emplace_kv_able<Table, K>::value,
       bool>::type
   {
     alloc_cted_or_fwded_key_type<type_policy, Allocator, K&&> x(

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

@@ -1,6 +1,6 @@
 /* Common base for Boost.Unordered open-addressing tables.
  *
- * Copyright 2022-2025 Joaquin M Lopez Munoz.
+ * Copyright 2022-2026 Joaquin M Lopez Munoz.
  * Copyright 2023 Christian Mazakas.
  * Copyright 2024 Braden Ganetsky.
  * Distributed under the Boost Software License, Version 1.0.
@@ -1349,7 +1349,7 @@ template <typename Container, typename K>
 using is_emplace_kv_able = std::integral_constant<bool,
   is_map<Container>::value &&
     (is_similar<K, typename Container::key_type>::value ||
-      is_complete_and_move_constructible<typename Container::key_type>::value)>;
+      std::is_move_constructible<typename Container::key_type>::value)>;
 
 /* table_core. The TypePolicy template parameter is used to generate
  * instantiations suitable for either maps or sets, and introduces non-standard

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

@@ -1,6 +1,6 @@
 /* Fast open-addressing hash table.
  *
- * Copyright 2022-2025 Joaquin M Lopez Munoz.
+ * Copyright 2022-2026 Joaquin M Lopez Munoz.
  * Copyright 2023 Christian Mazakas.
  * Copyright 2024 Braden Ganetsky.
  * Distributed under the Boost Software License, Version 1.0.
@@ -422,9 +422,9 @@ public:
   }
 
   /* Optimizations for maps for (k,v) to avoid eagerly constructing value */
-  template <typename K, typename V>
+  template <typename K, typename V, typename Table = table>
   BOOST_FORCEINLINE
-    typename std::enable_if<is_emplace_kv_able<table, K>::value,
+    typename std::enable_if<is_emplace_kv_able<Table, K>::value,
       std::pair<iterator, bool> >::type
     emplace(K&& k, V&& v)
   {

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

@@ -1,6 +1,6 @@
 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
 // Copyright (C) 2005-2016 Daniel James
-// Copyright (C) 2022-2024 Joaquin M Lopez Munoz.
+// Copyright (C) 2022-2026 Joaquin M Lopez Munoz.
 // Copyright (C) 2022-2023 Christian Mazakas
 // Copyright (C) 2024 Braden Ganetsky
 //
@@ -18,12 +18,14 @@
 #include <boost/unordered/detail/allocator_constructed.hpp>
 #include <boost/unordered/detail/fca.hpp>
 #include <boost/unordered/detail/opt_storage.hpp>
+#include <boost/unordered/detail/ranges_support.hpp>
 #include <boost/unordered/detail/serialize_tracked_address.hpp>
 #include <boost/unordered/detail/static_assert.hpp>
 #include <boost/unordered/detail/type_traits.hpp>
 #include <boost/unordered/detail/unordered_printers.hpp>
 
 #include <boost/assert.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/core/allocator_traits.hpp>
 #include <boost/core/bit.hpp>
 #include <boost/core/invoke_swap.hpp>
@@ -174,6 +176,29 @@ namespace boost {
           boost::unordered::detail::insert_size(i, j), num_buckets);
       }
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+      template<std::ranges::input_range R>
+      inline std::size_t insert_size(R&& rg)
+      {
+        if constexpr (std::ranges::sized_range<R>)
+          return std::ranges::size(std::forward<R>(rg));
+        else if constexpr (std::ranges::forward_range<R>)
+          return std::ranges::distance(std::forward<R>(rg));
+        else
+          return 1;
+      }
+
+      template <std::ranges::input_range R>
+      inline std::size_t initial_size(R&& rg,
+        std::size_t num_buckets =
+          boost::unordered::detail::default_bucket_count)
+      {
+        return (std::max)(
+          boost::unordered::detail::insert_size(std::forward<R>(rg)),
+          num_buckets);
+      }
+#endif
+
       //////////////////////////////////////////////////////////////////////////
       // compressed
 
@@ -954,10 +979,14 @@ namespace boost {
 
       inline std::size_t double_to_size(double f)
       {
-        return f >= static_cast<double>(
-                      (std::numeric_limits<std::size_t>::max)())
-                 ? (std::numeric_limits<std::size_t>::max)()
-                 : static_cast<std::size_t>(f);
+#if BOOST_WORKAROUND(BOOST_CLANG_VERSION, < 30900)
+        // https://github.com/boostorg/unordered/pull/354
+        volatile
+#endif
+        const double double_size_t_max =
+          static_cast<double>((std::numeric_limits<std::size_t>::max)());
+        return f >= double_size_t_max? 
+          (std::numeric_limits<std::size_t>::max)(): static_cast<std::size_t>(f);
       }
 
       //////////////////////////////////////////////////////////////////////////
@@ -1781,7 +1810,7 @@ namespace boost {
 
         static std::size_t min_buckets(std::size_t num_elements, float mlf)
         {
-          std::size_t num_buckets = static_cast<std::size_t>(
+          std::size_t num_buckets = boost::unordered::detail::double_to_size(
             std::ceil(static_cast<float>(num_elements) / mlf));
 
           if (num_buckets == 0 && num_elements > 0) { // mlf == inf
@@ -2150,8 +2179,8 @@ namespace boost {
         // if hash function throws, or inserting > 1 element, basic exception
         // safety strong otherwise
 
-        template <class InputIt>
-        void insert_range_unique(no_key, InputIt i, InputIt j)
+        template <class InputIt, class Sentinel>
+        void insert_range_unique(no_key, InputIt i, Sentinel j)
         {
           hasher const& hf = this->hash_function();
           node_allocator_type alloc = this->node_alloc();
@@ -2538,14 +2567,20 @@ namespace boost {
 
         // if hash function throws, or inserting > 1 element, basic exception
         // safety. Strong otherwise
-        template <class I>
+        template <class I, class S>
         typename boost::unordered::detail::enable_if_forward<I, void>::type
-        insert_range_equiv(I i, I j)
+        insert_range_equiv(I i, S j)
         {
           if (i == j)
             return;
 
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+          std::size_t distance = static_cast<std::size_t>(
+            std::ranges::distance(i, j));
+#else
           std::size_t distance = static_cast<std::size_t>(std::distance(i, j));
+#endif
+
           if (distance == 1) {
             emplace_equiv(boost::unordered::detail::func::construct_node(
               this->node_alloc(), *i));
@@ -2561,9 +2596,9 @@ namespace boost {
           }
         }
 
-        template <class I>
+        template <class I, class S>
         typename boost::unordered::detail::disable_if_forward<I, void>::type
-        insert_range_equiv(I i, I j)
+        insert_range_equiv(I i, S j)
         {
           for (; i != j; ++i) {
             emplace_equiv(boost::unordered::detail::func::construct_node(
@@ -2712,8 +2747,9 @@ namespace boost {
       inline void table<Types>::reserve_for_insert(std::size_t num_elements)
       {
         if (num_elements > max_load_) {
-          std::size_t const num_buckets = static_cast<std::size_t>(
-            1.0f + std::ceil(static_cast<float>(num_elements) / mlf_));
+          std::size_t const num_buckets = (std::max)(
+            static_cast<std::size_t>(1.0f + std::ceil(static_cast<float>(num_elements) / mlf_)),
+            static_cast<std::size_t>(bucket_count() + 1));
 
           this->rehash_impl(num_buckets);
         }
@@ -2851,10 +2887,10 @@ namespace boost {
           return no_key();
         }
 
-        template <class Arg1, class Arg2>
+        template <class Arg1, class Arg2, class Key = key_type>
         static typename std::conditional<
           (is_similar<Arg1, key_type>::value ||
-            is_complete_and_move_constructible<key_type>::value),
+            std::is_move_constructible<Key>::value),
           converting_key, no_key>::type
         extract(Arg1 const&, Arg2 const&)
         {

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

@@ -0,0 +1,104 @@
+/* Copyright 2026 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_RANGES_SUPPORT_HPP
+#define BOOST_UNORDERED_DETAIL_RANGES_SUPPORT_HPP
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#if defined(BOOST_NO_CXX20_HDR_CONCEPTS) || defined(BOOST_NO_CXX20_HDR_RANGES)
+#define BOOST_UNORDERED_NO_RANGES
+#elif BOOST_WORKAROUND(BOOST_CLANG_VERSION, < 170100) && \
+      defined(BOOST_LIBSTDCXX_VERSION)
+/* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109647
+ * https://github.com/llvm/llvm-project/issues/49620
+ */
+#define BOOST_UNORDERED_NO_RANGES
+#endif
+
+#if !defined(BOOST_UNORDERED_NO_RANGES)
+#include <concepts>
+#include <functional>
+#include <ranges>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace boost {
+namespace unordered {
+
+struct from_range_t { explicit from_range_t() = default; };
+inline constexpr from_range_t from_range{};
+
+namespace detail {
+
+/* Existence of std::from_range_t is governed by feature macro
+ * __cpp_lib_containers_ranges, but at least one stdlib implementation 
+ * (GCC 14.1) does not honor it, hence the workadound below: code picks 
+ * std::from_range_t if it exists, boost::unordered::from_range_t otherwise.
+ * Technique explained at
+ https://bannalia.blogspot.com/2016/09/compile-time-checking-existence-of.html
+ */
+
+struct from_range_t_hook{};
+
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+namespace std {
+
+template<> struct hash< ::boost::unordered::detail::from_range_t_hook>
+{
+  using from_range_t_type = decltype([] {
+    using namespace ::boost::unordered;
+    return from_range_t{};
+  }());
+
+  /* make standard happy */
+  std::size_t operator()(
+    const ::boost::unordered::detail::from_range_t_hook&) const;
+};
+
+} /* namespace std */
+
+namespace boost {
+namespace unordered {
+namespace detail {
+
+template<typename T>
+concept convertible_to_from_range_t =
+  std::is_convertible_v<T, boost::unordered::from_range_t> ||
+  std::is_convertible_v<T, std::hash<from_range_t_hook>::from_range_t_type>;
+
+template<class R, class T>
+concept container_compatible_range =
+  std::ranges::input_range<R> &&
+  std::convertible_to<std::ranges::range_reference_t<R>, T>;
+
+template<std::ranges::input_range Range>
+using range_key_t =
+  std::remove_cvref_t<
+    std::tuple_element_t<0, std::ranges::range_value_t<Range>>>;
+
+template<std::ranges::input_range Range>
+using range_mapped_t =
+  std::remove_cvref_t<
+    std::tuple_element_t<1, std::ranges::range_value_t<Range>>>;
+
+template<std::ranges::input_range Range>
+using range_to_alloc_t = 
+  std::pair<const range_key_t<Range>, range_mapped_t<Range>>;
+
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif /* !defined(BOOST_UNORDERED_NO_RANGES) */
+#endif

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

@@ -1,5 +1,6 @@
 // Copyright (C) 2022-2023 Christian Mazakas
 // Copyright (C) 2024 Braden Ganetsky
+// Copyright (C) 2026 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)
@@ -49,20 +50,6 @@ namespace boost {
 
       template <typename... Ts> using void_t = typename make_void<Ts...>::type;
 
-      template <class T, class = void> struct is_complete : std::false_type
-      {
-      };
-
-      template <class T>
-      struct is_complete<T, void_t<int[sizeof(T)]> > : std::true_type
-      {
-      };
-
-      template <class T>
-      using is_complete_and_move_constructible =
-        typename std::conditional<is_complete<T>::value,
-          std::is_move_constructible<T>, std::false_type>::type;
-
 #if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000)
       /* std::is_trivially_default_constructible not provided */
       template <class T>

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

@@ -1,8 +1,8 @@
-// Copyright 2024-2025 Braden Ganetsky
+// Copyright 2024-2026 Braden Ganetsky
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-// Generated on 2025-08-21T03:09:19
+// Generated on 2026-01-24T00:34:53
 
 #ifndef BOOST_UNORDERED_DETAIL_UNORDERED_PRINTERS_HPP
 #define BOOST_UNORDERED_DETAIL_UNORDERED_PRINTERS_HPP
@@ -29,8 +29,14 @@ __asm__(".pushsection \".debug_gdb_scripts\", \"MS\",%progbits,1\n"
         ".ascii \"            return n\\n\"\n"
 
         ".ascii \"    def maybe_unwrap_foa_element(e):\\n\"\n"
-        ".ascii \"        if f\\\"{e.type.strip_typedefs()}\\\".startswith(\\\"boost::unordered::detail::foa::element_type<\\\"):\\n\"\n"
-        ".ascii \"            return e[\\\"p\\\"]\\n\"\n"
+        ".ascii \"        # Sometimes the complex typedefs can't be resolved through a pointer\\n\"\n"
+        ".ascii \"        if e.type.strip_typedefs().code == gdb.TYPE_CODE_PTR:\\n\"\n"
+        ".ascii \"            foa_element = e.dereference()\\n\"\n"
+        ".ascii \"        else:\\n\"\n"
+        ".ascii \"            foa_element = e\\n\"\n"
+
+        ".ascii \"        if f\\\"{foa_element.type.strip_typedefs()}\\\".startswith(\\\"boost::unordered::detail::foa::element_type<\\\"):\\n\"\n"
+        ".ascii \"            return foa_element[\\\"p\\\"]\\n\"\n"
         ".ascii \"        else:\\n\"\n"
         ".ascii \"            return e\\n\"\n"