passenger 6.0.26 → 6.1.0

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

@@ -6,6 +6,8 @@
 #ifndef BOOST_UNORDERED_DETAIL_FOA_FLAT_MAP_TYPES_HPP
 #define BOOST_UNORDERED_DETAIL_FOA_FLAT_MAP_TYPES_HPP
 
+#include <boost/unordered/detail/foa/types_constructibility.hpp>
+
 #include <boost/core/allocator_access.hpp>
 
 namespace boost {
@@ -25,6 +27,9 @@ namespace boost {
 
           using element_type = value_type;
 
+          using types = flat_map_types<Key, T>;
+          using constructibility_checker = map_types_constructibility<types>;
+
           static value_type& value_from(element_type& x) { return x; }
 
           template <class K, class V>
@@ -48,18 +53,21 @@ namespace boost {
           template <class A, class... Args>
           static void construct(A& al, init_type* p, Args&&... args)
           {
+            constructibility_checker::check(al, p, std::forward<Args>(args)...);
             boost::allocator_construct(al, p, std::forward<Args>(args)...);
           }
 
           template <class A, class... Args>
           static void construct(A& al, value_type* p, Args&&... args)
           {
+            constructibility_checker::check(al, p, std::forward<Args>(args)...);
             boost::allocator_construct(al, p, std::forward<Args>(args)...);
           }
 
           template <class A, class... Args>
           static void construct(A& al, key_type* p, Args&&... args)
           {
+            constructibility_checker::check(al, p, std::forward<Args>(args)...);
             boost::allocator_construct(al, p, std::forward<Args>(args)...);
           }
 
@@ -79,8 +87,8 @@ namespace boost {
           }
         };
       } // namespace foa
-    }   // namespace detail
-  }     // namespace unordered
+    } // namespace detail
+  } // namespace unordered
 } // namespace boost
 
 #endif // BOOST_UNORDERED_DETAIL_FOA_FLAT_MAP_TYPES_HPP

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

@@ -5,6 +5,8 @@
 #ifndef BOOST_UNORDERED_DETAIL_FOA_FLAT_SET_TYPES_HPP
 #define BOOST_UNORDERED_DETAIL_FOA_FLAT_SET_TYPES_HPP
 
+#include <boost/unordered/detail/foa/types_constructibility.hpp>
+
 #include <boost/core/allocator_access.hpp>
 
 namespace boost {
@@ -21,6 +23,9 @@ namespace boost {
 
           using element_type = value_type;
 
+          using types = flat_set_types<Key>;
+          using constructibility_checker = set_types_constructibility<types>;
+
           static Key& value_from(element_type& x) { return x; }
 
           static element_type&& move(element_type& x) { return std::move(x); }
@@ -28,6 +33,7 @@ namespace boost {
           template <class A, class... Args>
           static void construct(A& al, value_type* p, Args&&... args)
           {
+            constructibility_checker::check(al, p, std::forward<Args>(args)...);
             boost::allocator_construct(al, p, std::forward<Args>(args)...);
           }
 
@@ -37,8 +43,8 @@ namespace boost {
           }
         };
       } // namespace foa
-    }   // namespace detail
-  }     // namespace unordered
+    } // namespace detail
+  } // namespace unordered
 } // namespace boost
 
 #endif // BOOST_UNORDERED_DETAIL_FOA_FLAT_SET_TYPES_HPP

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

@@ -1,4 +1,5 @@
 /* Copyright 2023 Christian Mazakas.
+ * Copyright 2024 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)
@@ -11,8 +12,11 @@
 
 #include <boost/unordered/detail/opt_storage.hpp>
 
+#include <boost/assert.hpp>
 #include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/core/allocator_access.hpp>
+#include <type_traits>
 
 namespace boost{
 namespace unordered{
@@ -27,6 +31,13 @@ struct insert_return_type
   NodeType node;
 };
 
+template <class NodeType>
+struct iteratorless_insert_return_type
+{
+  bool     inserted;
+  NodeType node;
+};
+
 template <class TypePolicy,class Allocator>
 struct node_handle_base
 {
@@ -42,7 +53,27 @@ struct node_handle_base
     element_type p_;
     BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS opt_storage<Allocator> a_;
 
-  protected:
+    friend struct node_handle_access;
+
+    template<bool B>
+    void move_assign_allocator_if(node_handle_base&& nh)noexcept
+    {
+      move_assign_allocator_if(
+        std::integral_constant<bool,B>{}, std::move(nh));
+    }
+
+    void move_assign_allocator_if(
+      std::true_type, node_handle_base&& nh)noexcept
+    {
+      al()=std::move(nh.al());
+    }
+
+    void move_assign_allocator_if(
+      std::false_type, node_handle_base&&)noexcept
+    {
+    }
+
+protected:
     node_value_type& data()noexcept
     {
       return *(p_.p);
@@ -126,9 +157,7 @@ struct node_handle_base
             BOOST_ASSERT(pocma||al()==nh.al());
 
             type_policy::destroy(al(),&p_);
-            if(pocma){
-              al()=std::move(nh.al());
-            }
+            move_assign_allocator_if<pocma>(std::move(nh));
 
             p_=std::move(nh.p_);
             nh.reset();
@@ -153,7 +182,17 @@ struct node_handle_base
       }
     }
 
-    allocator_type get_allocator()const noexcept{return al();}
+    allocator_type get_allocator()const
+    {
+#if defined(BOOST_GCC)
+      /* GCC lifetime analysis incorrectly warns about uninitialized
+       * allocator object under some circumstances.
+       */
+      if(empty())__builtin_unreachable();
+#endif
+      return al();
+    }
+
     explicit operator bool()const noexcept{ return !empty();}
     BOOST_ATTRIBUTE_NODISCARD bool empty()const noexcept{return p_.p==nullptr;}
 
@@ -196,6 +235,82 @@ struct node_handle_base
     }
 };
 
+// Internal usage of node_handle_base protected API
+
+struct node_handle_access
+{
+  template <class TypePolicy, class Allocator>
+  using node_type = node_handle_base<TypePolicy, Allocator>;
+
+#if BOOST_WORKAROUND(BOOST_CLANG_VERSION,<190000)
+  // https://github.com/llvm/llvm-project/issues/25708
+
+  template <class TypePolicy, class Allocator>
+  struct element_type_impl
+  {
+    using type = typename node_type<TypePolicy, Allocator>::element_type;
+  };
+  template <class TypePolicy, class Allocator>
+  using element_type = typename element_type_impl<TypePolicy, Allocator>::type;
+#else
+  template <class TypePolicy, class Allocator>
+  using element_type = typename node_type<TypePolicy, Allocator>::element_type;
+#endif
+
+  template <class TypePolicy, class Allocator>
+  static element_type<TypePolicy, Allocator>&
+  element(node_type<TypePolicy, Allocator>& nh)noexcept
+  {
+    return nh.element();
+  }
+
+  template <class TypePolicy, class Allocator>
+  static element_type<TypePolicy, Allocator>
+  const& element(node_type<TypePolicy, Allocator> const& nh)noexcept
+  {
+    return nh.element();
+  }
+
+  template <class TypePolicy, class Allocator>
+  static void emplace(
+    node_type<TypePolicy, Allocator>& nh,
+    element_type<TypePolicy, Allocator>&& x, Allocator a)
+  {
+    nh.emplace(std::move(x), a);
+  }
+
+  template <class TypePolicy,class Allocator>
+  static void reset(node_type<TypePolicy, Allocator>& nh)
+  {
+    nh.reset();
+  }
+};
+
+template <class TypePolicy, class Allocator>
+class node_handle_emplacer_class
+{
+  using access = node_handle_access;
+  using node_type = access::node_type<TypePolicy, Allocator>;
+  using element_type = access::element_type<TypePolicy, Allocator>;
+
+  node_type & nh;
+
+public:
+  node_handle_emplacer_class(node_type& nh_): nh(nh_) {}
+
+  void operator()(element_type&& x,Allocator a)
+  {
+    access::emplace(nh, std::move(x), a);
+  }
+};
+
+template <class TypePolicy, class Allocator>
+node_handle_emplacer_class<TypePolicy, Allocator>
+node_handle_emplacer(node_handle_base<TypePolicy, Allocator>& nh)
+{
+  return {nh};
+}
+
 }
 }
 }

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

@@ -0,0 +1,56 @@
+/* Copyright 2023 Christian Mazakas.
+ * Copyright 2024 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_FOA_NODE_MAP_HANDLE_HPP
+#define BOOST_UNORDERED_DETAIL_FOA_NODE_MAP_HANDLE_HPP
+
+#include <boost/unordered/detail/foa/node_handle.hpp>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+template <class TypePolicy, class Allocator>
+struct node_map_handle
+    : public node_handle_base<TypePolicy, Allocator>
+{
+private:
+  using base_type = node_handle_base<TypePolicy, Allocator>;
+
+  using typename base_type::type_policy;
+
+public:
+  using key_type = typename TypePolicy::key_type;
+  using mapped_type = typename TypePolicy::mapped_type;
+
+  constexpr node_map_handle() noexcept = default;
+  node_map_handle(node_map_handle&& nh) noexcept = default;
+
+  node_map_handle& operator=(node_map_handle&&) noexcept = default;
+
+  key_type& key() const
+  {
+    BOOST_ASSERT(!this->empty());
+    return const_cast<key_type&>(this->data().first);
+  }
+
+  mapped_type& mapped() const
+  {
+    BOOST_ASSERT(!this->empty());
+    return const_cast<mapped_type&>(this->data().second);
+  }
+};
+
+}
+}
+}
+}
+
+#endif // BOOST_UNORDERED_DETAIL_FOA_NODE_MAP_HANDLE_HPP

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

@@ -7,6 +7,8 @@
 #define BOOST_UNORDERED_DETAIL_FOA_NODE_MAP_TYPES_HPP
 
 #include <boost/unordered/detail/foa/element_type.hpp>
+#include <boost/unordered/detail/foa/types_constructibility.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
 
 #include <boost/core/allocator_access.hpp>
 #include <boost/core/no_exceptions_support.hpp>
@@ -29,6 +31,9 @@ namespace boost {
 
           using element_type = foa::element_type<value_type, VoidPtr>;
 
+          using types = node_map_types<Key, T, VoidPtr>;
+          using constructibility_checker = map_types_constructibility<types>;
+
           static value_type& value_from(element_type const& x)
           {
             return *(x.p);
@@ -68,24 +73,27 @@ namespace boost {
           static void construct(
             A& al, element_type* p, element_type const& copy)
           {
-            construct(al, p, *copy.p);
+            construct(al, p, detail::as_const(*copy.p));
           }
 
           template <class A, class... Args>
           static void construct(A& al, init_type* p, Args&&... args)
           {
+            constructibility_checker::check(al, p, std::forward<Args>(args)...);
             boost::allocator_construct(al, p, std::forward<Args>(args)...);
           }
 
           template <class A, class... Args>
           static void construct(A& al, value_type* p, Args&&... args)
           {
+            constructibility_checker::check(al, p, std::forward<Args>(args)...);
             boost::allocator_construct(al, p, std::forward<Args>(args)...);
           }
 
           template <class A, class... Args>
           static void construct(A& al, key_type* p, Args&&... args)
           {
+            constructibility_checker::check(al, p, std::forward<Args>(args)...);
             boost::allocator_construct(al, p, std::forward<Args>(args)...);
           }
 
@@ -95,8 +103,11 @@ namespace boost {
             p->p = boost::allocator_allocate(al, 1);
             BOOST_TRY
             {
+              auto address = boost::to_address(p->p);
+              constructibility_checker::check(
+                al, address, std::forward<Args>(args)...);
               boost::allocator_construct(
-                al, boost::to_address(p->p), std::forward<Args>(args)...);
+                al, address, std::forward<Args>(args)...);
             }
             BOOST_CATCH(...)
             {
@@ -132,8 +143,8 @@ namespace boost {
         };
 
       } // namespace foa
-    }   // namespace detail
-  }     // namespace unordered
+    } // namespace detail
+  } // namespace unordered
 } // namespace boost
 
 #endif // BOOST_UNORDERED_DETAIL_FOA_NODE_MAP_TYPES_HPP

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

@@ -0,0 +1,48 @@
+/* Copyright 2023 Christian Mazakas.
+ * Copyright 2024 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_FOA_NODE_SET_HANDLE_HPP
+#define BOOST_UNORDERED_DETAIL_FOA_NODE_SET_HANDLE_HPP
+
+#include <boost/unordered/detail/foa/node_handle.hpp>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+template <class TypePolicy, class Allocator>
+struct node_set_handle
+    : public detail::foa::node_handle_base<TypePolicy, Allocator>
+{
+private:
+  using base_type = detail::foa::node_handle_base<TypePolicy, Allocator>;
+
+  using typename base_type::type_policy;
+
+public:
+  using value_type = typename TypePolicy::value_type;
+
+  constexpr node_set_handle() noexcept = default;
+  node_set_handle(node_set_handle&& nh) noexcept = default;
+  node_set_handle& operator=(node_set_handle&&) noexcept = default;
+
+  value_type& value() const
+  {
+    BOOST_ASSERT(!this->empty());
+    return const_cast<value_type&>(this->data());
+  }
+};
+
+}
+}
+}
+}
+
+#endif // BOOST_UNORDERED_DETAIL_FOA_NODE_SET_HANDLE_HPP

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

@@ -6,6 +6,8 @@
 #define BOOST_UNORDERED_DETAIL_FOA_NODE_SET_TYPES_HPP
 
 #include <boost/unordered/detail/foa/element_type.hpp>
+#include <boost/unordered/detail/foa/types_constructibility.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
 
 #include <boost/core/allocator_access.hpp>
 #include <boost/core/no_exceptions_support.hpp>
@@ -26,6 +28,9 @@ namespace boost {
 
           using element_type = foa::element_type<value_type, VoidPtr>;
 
+          using types = node_set_types<Key, VoidPtr>;
+          using constructibility_checker = set_types_constructibility<types>;
+
           static value_type& value_from(element_type const& x) { return *x.p; }
           static Key const& extract(element_type const& k) { return *k.p; }
           static element_type&& move(element_type& x) { return std::move(x); }
@@ -35,7 +40,7 @@ namespace boost {
           static void construct(
             A& al, element_type* p, element_type const& copy)
           {
-            construct(al, p, *copy.p);
+            construct(al, p, detail::as_const(*copy.p));
           }
 
           template <typename Allocator>
@@ -49,6 +54,7 @@ namespace boost {
           template <class A, class... Args>
           static void construct(A& al, value_type* p, Args&&... args)
           {
+            constructibility_checker::check(al, p, std::forward<Args>(args)...);
             boost::allocator_construct(al, p, std::forward<Args>(args)...);
           }
 
@@ -58,8 +64,11 @@ namespace boost {
             p->p = boost::allocator_allocate(al, 1);
             BOOST_TRY
             {
+              auto address = boost::to_address(p->p);
+              constructibility_checker::check(
+                al, address, std::forward<Args>(args)...);
               boost::allocator_construct(
-                al, boost::to_address(p->p), std::forward<Args>(args)...);
+                al, address, std::forward<Args>(args)...);
             }
             BOOST_CATCH(...)
             {
@@ -85,8 +94,8 @@ namespace boost {
         };
 
       } // namespace foa
-    }   // namespace detail
-  }     // namespace unordered
+    } // namespace detail
+  } // namespace unordered
 } // namespace boost
 
 #endif // BOOST_UNORDERED_DETAIL_FOA_NODE_SET_TYPES_HPP

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

@@ -1,4 +1,4 @@
-/* Copyright 2023 Joaquin M Lopez Munoz.
+/* Copyright 2023-2024 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)
@@ -19,27 +19,28 @@ namespace unordered{
 namespace detail{
 namespace foa{
 
-template<typename Tuple>
+template<std::size_t Offset,typename Tuple>
 using tuple_rotate_right_return_type=mp11::mp_rotate_right_c<
   typename std::remove_cv<typename std::remove_reference<Tuple>::type>::type,
-  1
+  Offset
 >;
 
-template<std::size_t... Is,typename Tuple>
-tuple_rotate_right_return_type<Tuple>
+template<std::size_t Offset,std::size_t... Is,typename Tuple>
+tuple_rotate_right_return_type<Offset,Tuple>
 tuple_rotate_right_aux(mp11::index_sequence<Is...>,Tuple&& x)
 {
-  return tuple_rotate_right_return_type<Tuple>{
-    std::get<(Is+sizeof...(Is)-1)%sizeof...(Is)>(std::forward<Tuple>(x))...};
+  return tuple_rotate_right_return_type<Offset,Tuple>{
+    std::get<(Is+sizeof...(Is)-Offset)%sizeof...(Is)>(
+      std::forward<Tuple>(x))...};
 }
 
-template<typename Tuple>
-tuple_rotate_right_return_type<Tuple> tuple_rotate_right(Tuple&& x)
+template<std::size_t Offset=1,typename Tuple>
+tuple_rotate_right_return_type<Offset,Tuple> tuple_rotate_right(Tuple&& x)
 {
   using RawTuple=typename std::remove_cv<
     typename std::remove_reference<Tuple>::type>::type;
 
-  return tuple_rotate_right_aux(
+  return tuple_rotate_right_aux<Offset>(
     mp11::make_index_sequence<std::tuple_size<RawTuple>::value>{},
     std::forward<Tuple>(x));
 }