passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/describe/modifiers.hpp

@@ -25,7 +25,7 @@ enum modifiers
     mod_hidden = 256
 };
 
-BOOST_DESCRIBE_CONSTEXPR_OR_CONST modifiers mod_any_access = static_cast<modifiers>( mod_public | mod_protected | mod_private );
+BOOST_DESCRIBE_INLINE_CONSTEXPR modifiers mod_any_access = static_cast<modifiers>( mod_public | mod_protected | mod_private );
 
 } // namespace describe
 } // namespace boost

data/src/cxx_supportlib/vendor-modified/boost/foreach.hpp

@@ -88,6 +88,7 @@
 #include <boost/type_traits/is_abstract.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 #include <boost/type_traits/is_rvalue_reference.hpp>
+#include <boost/type_traits/is_convertible.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/utility/addressof.hpp>
 #include <boost/foreach_fwd.hpp>

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/ebo_functor_holder.hpp

@@ -88,7 +88,7 @@ struct is_unary_or_binary_function_impl<R (*)(T0)>
 {  static const bool value = true;  };
 
 template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (*)(T0...)>
+struct is_unary_or_binary_function_impl<R (*)(T0, ...)>
 {  static const bool value = true;  };
 
 #else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
@@ -110,7 +110,7 @@ struct is_unary_or_binary_function_impl<R (__cdecl*)(T0)>
 {  static const bool value = true;  };
 
 template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0...)>
+struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, ...)>
 {  static const bool value = true;  };
 
 #endif
@@ -124,7 +124,7 @@ struct is_unary_or_binary_function_impl<R (*)(T0, T1)>
 {  static const bool value = true;  };
 
 template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (*)(T0, T1...)>
+struct is_unary_or_binary_function_impl<R (*)(T0, T1, ...)>
 {  static const bool value = true;  };
 
 #else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
@@ -146,7 +146,7 @@ struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1)>
 {  static const bool value = true;  };
 
 template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1...)>
+struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1, ...)>
 {  static const bool value = true;  };
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/list.hpp

@@ -1260,7 +1260,7 @@ class list_impl
       }
    }
 
-   //! <b>Requires</b>: value must be a reference to a value inserted in a list.
+   //! <b>Requires</b>: `value` must be a reference to a value inserted in an instance of this container type.
    //!
    //! <b>Effects</b>: This function returns a const_iterator pointing to the element
    //!
@@ -1297,7 +1297,7 @@ class list_impl
       return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
    }
 
-   //! <b>Requires</b>: value must be a reference to a value inserted in a list.
+   //! <b>Requires</b>: `value` must be a reference to a value inserted in an instance of this container type.
    //!
    //! <b>Effects</b>: This function returns a const_iterator pointing to the element
    //!

data/src/cxx_supportlib/vendor-modified/boost/intrusive/pointer_rebind.hpp

@@ -26,6 +26,11 @@
 namespace boost {
 namespace intrusive {
 
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 ///////////////////////////
 //struct pointer_rebind_mode
 ///////////////////////////
@@ -182,6 +187,10 @@ template <typename T, typename U>
 struct pointer_rebind<T*, U>
 {  typedef U* type; };
 
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#  pragma GCC diagnostic pop
+#endif
+
 }  //namespace container {
 }  //namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/rbtree_algorithms.hpp

@@ -508,6 +508,7 @@ class rbtree_algorithms
          else {
             // same as above, with right_ <-> left_.
             node_ptr w = x_parent_left;
+            BOOST_INTRUSIVE_INVARIANT_ASSERT(w);
             if(NodeTraits::get_color(w) == NodeTraits::red()){
                NodeTraits::set_color(w, NodeTraits::black());
                NodeTraits::set_color(x_parent, NodeTraits::red());

data/src/cxx_supportlib/vendor-modified/boost/intrusive/slist.hpp

@@ -1742,7 +1742,7 @@ class slist_impl
       }
    }
 
-   //! <b>Requires</b>: value must be a reference to a value inserted in a list.
+   //! <b>Requires</b>: `value` must be a reference to a value inserted in an instance of this container type.
    //!
    //! <b>Effects</b>: This function returns a const_iterator pointing to the element
    //!
@@ -1777,7 +1777,7 @@ class slist_impl
       return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
    }
 
-   //! <b>Requires</b>: value must be a reference to a value inserted in a list.
+   //! <b>Requires</b>: `value` must be a reference to a value inserted in an instance of this container type.
    //!
    //! <b>Effects</b>: This function returns a const_iterator pointing to the element
    //!

data/src/cxx_supportlib/vendor-modified/boost/iterator/advance.hpp

@@ -8,83 +8,62 @@
 #define BOOST_ITERATOR_ADVANCE_HPP
 
 #include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 
 namespace boost {
 namespace iterators {
+namespace detail {
 
-    namespace detail {
-        template <typename InputIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance_impl(
-            InputIterator& it
-          , Distance n
-          , incrementable_traversal_tag
-        )
-        {
-            while (n > 0) {
-                ++it;
-                --n;
-            }
-        }
-
-#if BOOST_WORKAROUND(BOOST_GCC_VERSION, >= 40600)
-// type-limits warning issued below when n is an unsigned integral
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wtype-limits"
-#endif
-
-        template <typename BidirectionalIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance_impl(
-            BidirectionalIterator& it
-          , Distance n
-          , bidirectional_traversal_tag
-        )
-        {
-            if (n >= 0) {
-                while (n > 0) {
-                    ++it;
-                    --n;
-                }
-            }
-            else {
-                while (n < 0) {
-                    --it;
-                    ++n;
-                }
-            }
-        }
-
-#if BOOST_WORKAROUND(BOOST_GCC_VERSION, >= 40600)
-#pragma GCC diagnostic pop
-#endif
+template< typename InputIterator, typename Distance >
+inline BOOST_CXX14_CONSTEXPR void advance_impl(InputIterator& it, Distance n, incrementable_traversal_tag)
+{
+    while (n > 0)
+    {
+        ++it;
+        --n;
+    }
+}
 
-        template <typename RandomAccessIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance_impl(
-            RandomAccessIterator& it
-          , Distance n
-          , random_access_traversal_tag
-        )
+template< typename BidirectionalIterator, typename Distance >
+inline BOOST_CXX14_CONSTEXPR void advance_impl(BidirectionalIterator& it, Distance n, bidirectional_traversal_tag)
+{
+    if (n >= 0)
+    {
+        while (n > 0)
         {
-            it += n;
+            ++it;
+            --n;
         }
     }
-
-    namespace advance_adl_barrier {
-        template <typename InputIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance(InputIterator& it, Distance n)
+    else
+    {
+        while (n < 0)
         {
-            detail::advance_impl(
-                it, n, typename iterator_traversal<InputIterator>::type()
-            );
+            --it;
+            ++n;
         }
     }
+}
+
+template< typename RandomAccessIterator, typename Distance >
+inline BOOST_CXX14_CONSTEXPR void advance_impl(RandomAccessIterator& it, Distance n, random_access_traversal_tag)
+{
+    it += n;
+}
+
+} // namespace detail
+
+namespace advance_adl_barrier {
+
+template< typename InputIterator, typename Distance >
+inline BOOST_CXX14_CONSTEXPR void advance(InputIterator& it, Distance n)
+{
+    detail::advance_impl(it, n, typename iterator_traversal< InputIterator >::type());
+}
+
+} // namespace advance_adl_barrier
 
-    using namespace advance_adl_barrier;
+using namespace advance_adl_barrier;
 
 } // namespace iterators
 

data/src/cxx_supportlib/vendor-modified/boost/iterator/detail/config_def.hpp

@@ -26,8 +26,6 @@
 // libs/iterator/test/constant_iterator_arrow.cpp fails to compile
 // because the operator-> return is improperly deduced as a non-const
 // pointer.
-#if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
-    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x531))
 
 // Recall that in general, compilers without partial specialization
 // can't strip constness.  Consider counting_iterator, which normally
@@ -44,85 +42,4 @@
 
 # define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
 
-#endif
-
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x5A0))                      \
-    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
-    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
-    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-
-# define BOOST_NO_LVALUE_RETURN_DETECTION
-
-# if 0 // test code
-  struct v  {};
-
-  typedef  char (&no)[3];
-
-  template <class T>
-  no foo(T const&, ...);
-
-  template <class T>
-  char foo(T&, int);
-
-
-  struct value_iterator
-  {
-      v operator*() const;
-  };
-
-  template <class T>
-  struct lvalue_deref_helper
-  {
-      static T& x;
-      enum { value = (sizeof(foo(*x,0)) == 1) };
-  };
-
-  int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1];
-  int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ];
-# endif
-
-#endif
-
-#if BOOST_WORKAROUND(__MWERKS__, <=0x2407)
-#  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
-#endif
-
-#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
-    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
-#  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
-
-#  if 0 // test code
-    #include <boost/type_traits/is_convertible.hpp>
-    template <class T>
-    struct foo
-    {
-        foo(T);
-
-        template <class U>
-        foo(foo<U> const& other) : p(other.p) { }
-
-        T p;
-    };
-
-    bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value;
-#  endif
-
-#endif
-
-
-#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
-# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#endif
-
-# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
-
-// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
-// operators in convertibility checks, causing premature errors.
-//
-// Borland's problems are harder to diagnose due to lack of an
-// instantiation stack backtrace.  They may be due in part to the fact
-// that it drops cv-qualification willy-nilly in templates.
-#  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
-# endif
-
 // no include guard; multiple inclusion intended

data/src/cxx_supportlib/vendor-modified/boost/iterator/detail/config_undef.hpp

@@ -11,11 +11,7 @@
 // 23/02/03 thw
 //
 
-#undef BOOST_NO_IS_CONVERTIBLE
-#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
-#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#undef BOOST_NO_LVALUE_RETURN_DETECTION
-#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+#undef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
 
 #ifdef BOOST_ITERATOR_CONFIG_DEF
 # undef BOOST_ITERATOR_CONFIG_DEF

data/src/cxx_supportlib/vendor-modified/boost/iterator/detail/eval_if_default.hpp

@@ -0,0 +1,44 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2025 Andrey Semashev
+ */
+
+#ifndef BOOST_ITERATOR_DETAIL_EVAL_IF_DEFAULT_HPP_INCLUDED_
+#define BOOST_ITERATOR_DETAIL_EVAL_IF_DEFAULT_HPP_INCLUDED_
+
+#include <boost/core/use_default.hpp>
+#include <boost/iterator/detail/type_traits/type_identity.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+// If T is use_default, return the result of invoking
+// DefaultNullaryFn, otherwise - of NondefaultNullaryFn.
+// By default, NondefaultNullaryFn returns T, which means
+// the metafunction can be called with just two parameters
+// and in that case will return either T or the result of
+// invoking DefaultNullaryFn.
+template< typename T, typename DefaultNullaryFn, typename NondefaultNullaryFn = detail::type_identity< T > >
+struct eval_if_default
+{
+    using type = typename NondefaultNullaryFn::type;
+};
+
+template< typename DefaultNullaryFn, typename NondefaultNullaryFn >
+struct eval_if_default< use_default, DefaultNullaryFn, NondefaultNullaryFn >
+{
+    using type = typename DefaultNullaryFn::type;
+};
+
+template< typename T, typename DefaultNullaryFn, typename NondefaultNullaryFn = detail::type_identity< T > >
+using eval_if_default_t = typename eval_if_default< T, DefaultNullaryFn, NondefaultNullaryFn >::type;
+
+} // namespace detail
+} // namespace iterators
+} // namespace boost
+
+#endif // BOOST_ITERATOR_DETAIL_EVAL_IF_DEFAULT_HPP_INCLUDED_