passenger 6.1.0 → 6.1.1

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

@@ -4,168 +4,137 @@
 // 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_TRANSFORM_ITERATOR_23022003THW_HPP
-#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
-
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
-#include <boost/iterator/detail/enable_if.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/type_traits/function_traits.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/result_of.hpp>
+#ifndef BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP
+#define BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP
 
 #include <iterator>
+#include <type_traits>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-#include <boost/type_traits/is_base_and_derived.hpp>
-#endif
-
-#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-#include <boost/static_assert.hpp>
-#endif
-
-#include <boost/iterator/detail/config_def.hpp>
-
+#include <boost/core/use_default.hpp>
+#include <boost/core/empty_value.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/enable_if_convertible.hpp>
+#include <boost/iterator/detail/eval_if_default.hpp>
 
 namespace boost {
 namespace iterators {
 
-  template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
-  class transform_iterator;
-
-  namespace detail
-  {
-    // Compute the iterator_adaptor instantiation to be used for transform_iterator
-    template <class UnaryFunc, class Iterator, class Reference, class Value>
-    struct transform_iterator_base
-    {
-     private:
-        // By default, dereferencing the iterator yields the same as
-        // the function.
-        typedef typename ia_dflt_help<
-            Reference
-#ifdef BOOST_RESULT_OF_USE_TR1
-          , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
-#else
-          , result_of<const UnaryFunc&(typename std::iterator_traits<Iterator>::reference)>
-#endif
-        >::type reference;
-
-        // To get the default for Value: remove any reference on the
-        // result type, but retain any constness to signal
-        // non-writability.  Note that if we adopt Thomas' suggestion
-        // to key non-writability *only* on the Reference argument,
-        // we'd need to strip constness here as well.
-        typedef typename ia_dflt_help<
-            Value
-          , remove_reference<reference>
-        >::type cv_value_type;
-
-     public:
-        typedef iterator_adaptor<
-            transform_iterator<UnaryFunc, Iterator, Reference, Value>
-          , Iterator
-          , cv_value_type
-          , use_default    // Leave the traversal category alone
-          , reference
-        > type;
-    };
-  }
-
-  template <class UnaryFunc, class Iterator, class Reference, class Value>
-  class transform_iterator
-    : public boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
-  {
-    typedef typename
-    boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
-    super_t;
-
+template<
+    typename UnaryFunction,
+    typename Iterator,
+    typename Reference = use_default,
+    typename Value = use_default
+>
+class transform_iterator;
+
+namespace detail {
+
+template< typename UnaryFunc, typename Iterator >
+struct transform_iterator_default_reference
+{
+    using type = decltype(std::declval< UnaryFunc const& >()(std::declval< typename std::iterator_traits< Iterator >::reference >()));
+};
+
+// Compute the iterator_adaptor instantiation to be used for transform_iterator
+template< typename UnaryFunc, typename Iterator, typename Reference, typename Value >
+struct transform_iterator_base
+{
+private:
+    // By default, dereferencing the iterator yields the same as
+    // the function.
+    using reference = detail::eval_if_default_t<
+        Reference,
+        transform_iterator_default_reference< UnaryFunc, Iterator >
+    >;
+
+    // To get the default for Value: remove any reference on the
+    // result type, but retain any constness to signal
+    // non-writability.  Note that if we adopt Thomas' suggestion
+    // to key non-writability *only* on the Reference argument,
+    // we'd need to strip constness here as well.
+    using cv_value_type = detail::eval_if_default_t<
+        Value,
+        std::remove_reference< reference >
+    >;
+
+public:
+    using type = iterator_adaptor<
+        transform_iterator< UnaryFunc, Iterator, Reference, Value >,
+        Iterator,
+        cv_value_type,
+        use_default,    // Leave the traversal category alone
+        reference
+    >;
+};
+
+} // namespace detail
+
+template< typename UnaryFunc, typename Iterator, typename Reference, typename Value >
+class transform_iterator :
+    public detail::transform_iterator_base< UnaryFunc, Iterator, Reference, Value >::type,
+    private boost::empty_value< UnaryFunc >
+{
     friend class iterator_core_access;
 
-  public:
-    transform_iterator() { }
-
-    transform_iterator(Iterator const& x, UnaryFunc f)
-      : super_t(x), m_f(f) { }
-
-    explicit transform_iterator(Iterator const& x)
-      : super_t(x)
-    {
-        // Pro8 is a little too aggressive about instantiating the
-        // body of this function.
-#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-        // don't provide this constructor if UnaryFunc is a
-        // function pointer type, since it will be 0.  Too dangerous.
-        BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value);
-#endif
-    }
-
-    template <
-        class OtherUnaryFunction
-      , class OtherIterator
-      , class OtherReference
-      , class OtherValue>
-    transform_iterator(
-         transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
-       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
-#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0
-#endif
-    )
-      : super_t(t.base()), m_f(t.functor())
-   {}
-
-    UnaryFunc functor() const
-      { return m_f; }
-
-  private:
-    typename super_t::reference dereference() const
-    { return m_f(*this->base()); }
-
-    // Probably should be the initial base class so it can be
-    // optimized away via EBO if it is an empty class.
-    UnaryFunc m_f;
-  };
-
-  template <class UnaryFunc, class Iterator>
-  inline transform_iterator<UnaryFunc, Iterator>
-  make_transform_iterator(Iterator it, UnaryFunc fun)
-  {
-      return transform_iterator<UnaryFunc, Iterator>(it, fun);
-  }
-
-  // Version which allows explicit specification of the UnaryFunc
-  // type.
-  //
-  // This generator is not provided if UnaryFunc is a function
-  // pointer type, because it's too dangerous: the default-constructed
-  // function pointer in the iterator be 0, leading to a runtime
-  // crash.
-  template <class UnaryFunc, class Iterator>
-  inline typename iterators::enable_if<
-      is_class<UnaryFunc>   // We should probably find a cheaper test than is_class<>
-    , transform_iterator<UnaryFunc, Iterator>
-  >::type
-  make_transform_iterator(Iterator it)
-  {
-      return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());
-  }
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-  template <class Return, class Argument, class Iterator>
-  inline transform_iterator< Return (*)(Argument), Iterator, Return>
-  make_transform_iterator(Iterator it, Return (*fun)(Argument))
-  {
-    return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun);
-  }
-#endif
+private:
+    using super_t = typename detail::transform_iterator_base< UnaryFunc, Iterator, Reference, Value >::type;
+    using functor_base = boost::empty_value< UnaryFunc >;
+
+public:
+    transform_iterator() = default;
+
+    transform_iterator(Iterator const& x, UnaryFunc f) :
+        super_t(x),
+        functor_base(boost::empty_init_t{}, f)
+    {}
+
+    // don't provide this constructor if UnaryFunc is a
+    // function pointer type, since it will be 0.  Too dangerous.
+    template< bool Requires = std::is_class< UnaryFunc >::value, typename = typename std::enable_if< Requires >::type >
+    explicit transform_iterator(Iterator const& x) :
+        super_t(x)
+    {}
+
+    template<
+        typename OtherUnaryFunction,
+        typename OtherIterator,
+        typename OtherReference,
+        typename OtherValue,
+        typename = enable_if_convertible_t< OtherIterator, Iterator >,
+        typename = enable_if_convertible_t< OtherUnaryFunction, UnaryFunc >
+    >
+    transform_iterator(transform_iterator< OtherUnaryFunction, OtherIterator, OtherReference, OtherValue > const& t) :
+        super_t(t.base()),
+        functor_base(boost::empty_init_t{}, t.functor())
+    {}
+
+    UnaryFunc functor() const { return functor_base::get(); }
+
+private:
+    typename super_t::reference dereference() const { return functor_base::get()(*this->base()); }
+};
+
+template< typename UnaryFunc, typename Iterator >
+inline transform_iterator< UnaryFunc, Iterator > make_transform_iterator(Iterator it, UnaryFunc fun)
+{
+    return transform_iterator< UnaryFunc, Iterator >(it, fun);
+}
+
+// Version which allows explicit specification of the UnaryFunc
+// type.
+//
+// This generator is not provided if UnaryFunc is a function
+// pointer type, because it's too dangerous: the default-constructed
+// function pointer in the iterator be 0, leading to a runtime
+// crash.
+template< typename UnaryFunc, typename Iterator >
+inline typename std::enable_if<
+    std::is_class< UnaryFunc >::value,   // We should probably find a cheaper test than is_class<>
+    transform_iterator< UnaryFunc, Iterator >
+>::type make_transform_iterator(Iterator it)
+{
+    return transform_iterator< UnaryFunc, Iterator >(it);
+}
 
 } // namespace iterators
 
@@ -174,6 +143,4 @@ using iterators::make_transform_iterator;
 
 } // namespace boost
 
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
+#endif // BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/bad_lexical_cast.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/buffer_view.hpp

@@ -1,4 +1,4 @@
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_lexical.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -29,16 +29,13 @@
 
 #include <cstddef>
 #include <string>
+#include <type_traits>
 #include <boost/limits.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/type_identity.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_float.hpp>
 #include <boost/detail/lcast_precision.hpp>
 
 #include <boost/lexical_cast/detail/widest_char.hpp>
 #include <boost/lexical_cast/detail/is_character.hpp>
+#include <boost/lexical_cast/detail/type_traits.hpp>
 
 #include <array>
 
@@ -68,19 +65,19 @@ namespace boost {
         template < class Char >
         struct normalize_single_byte_char
         {
-            typedef Char type;
+            using type = Char;
         };
 
         template <>
         struct normalize_single_byte_char< signed char >
         {
-            typedef char type;
+            using type = char;
         };
 
         template <>
         struct normalize_single_byte_char< unsigned char >
         {
-            typedef char type;
+            using type = char;
         };
     }
 
@@ -97,21 +94,21 @@ namespace boost {
         // Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types
         // Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>)
         template < typename Type >
-        struct stream_char_common: public boost::conditional<
+        struct stream_char_common: public std::conditional<
             boost::detail::is_character< Type >::value,
             Type,
             boost::detail::deduce_character_type_later< Type >
         > {};
 
         template < typename Char >
-        struct stream_char_common< Char* >: public boost::conditional<
+        struct stream_char_common< Char* >: public std::conditional<
             boost::detail::is_character< Char >::value,
             Char,
             boost::detail::deduce_character_type_later< Char* >
         > {};
 
         template < typename Char >
-        struct stream_char_common< const Char* >: public boost::conditional<
+        struct stream_char_common< const Char* >: public std::conditional<
             boost::detail::is_character< Char >::value,
             Char,
             boost::detail::deduce_character_type_later< const Char* >
@@ -120,18 +117,18 @@ namespace boost {
         template < typename Char >
         struct stream_char_common< boost::conversion::detail::buffer_view< Char > >
         {
-            typedef Char type;
+            using type = Char;
         };
 
         template < typename Char >
-        struct stream_char_common< boost::iterator_range< Char* > >: public boost::conditional<
+        struct stream_char_common< boost::iterator_range< Char* > >: public std::conditional<
             boost::detail::is_character< Char >::value,
             Char,
             boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
         > {};
 
         template < typename Char >
-        struct stream_char_common< boost::iterator_range< const Char* > >: public boost::conditional<
+        struct stream_char_common< boost::iterator_range< const Char* > >: public std::conditional<
             boost::detail::is_character< Char >::value,
             Char,
             boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
@@ -140,24 +137,24 @@ namespace boost {
         template < class Char, class Traits, class Alloc >
         struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
         {
-            typedef Char type;
+            using type = Char;
         };
 
         template < class Char, class Traits, class Alloc >
         struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
         {
-            typedef Char type;
+            using type = Char;
         };
 
         template < typename Char, std::size_t N >
-        struct stream_char_common< boost::array< Char, N > >: public boost::conditional<
+        struct stream_char_common< boost::array< Char, N > >: public std::conditional<
             boost::detail::is_character< Char >::value,
             Char,
             boost::detail::deduce_character_type_later< boost::array< Char, N > >
         > {};
 
         template < typename Char, std::size_t N >
-        struct stream_char_common< boost::array< const Char, N > >: public boost::conditional<
+        struct stream_char_common< boost::array< const Char, N > >: public std::conditional<
             boost::detail::is_character< Char >::value,
             Char,
             boost::detail::deduce_character_type_later< boost::array< const Char, N > >
@@ -165,14 +162,14 @@ namespace boost {
 
 #ifndef BOOST_NO_CXX11_HDR_ARRAY
         template < typename Char, std::size_t N >
-        struct stream_char_common< std::array<Char, N > >: public boost::conditional<
+        struct stream_char_common< std::array<Char, N > >: public std::conditional<
             boost::detail::is_character< Char >::value,
             Char,
             boost::detail::deduce_character_type_later< std::array< Char, N > >
         > {};
 
         template < typename Char, std::size_t N >
-        struct stream_char_common< std::array< const Char, N > >: public boost::conditional<
+        struct stream_char_common< std::array< const Char, N > >: public std::conditional<
             boost::detail::is_character< Char >::value,
             Char,
             boost::detail::deduce_character_type_later< std::array< const Char, N > >
@@ -183,25 +180,31 @@ namespace boost {
         template < class Char, class Traits >
         struct stream_char_common< std::basic_string_view< Char, Traits > >
         {
-            typedef Char type;
+            using type = Char;
         };
 #endif
         template < class Char, class Traits >
         struct stream_char_common< boost::basic_string_view< Char, Traits > >
         {
-            typedef Char type;
+            using type = Char;
         };
 
 #ifdef BOOST_HAS_INT128
-        template <> struct stream_char_common< boost::int128_type >: public boost::type_identity< char > {};
-        template <> struct stream_char_common< boost::uint128_type >: public boost::type_identity< char > {};
+        template <> struct stream_char_common< boost::int128_type >
+        {
+            using type = char;
+        };
+        template <> struct stream_char_common< boost::uint128_type >
+        {
+            using type = char;
+        };
 #endif
 
 #if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
         template <>
         struct stream_char_common< wchar_t >
         {
-            typedef char type;
+            using type = char;
         };
 #endif
     }
@@ -363,7 +366,7 @@ namespace boost {
         // When is_specialized is false, the whole expression is 0.
         template <class Source>
         struct lcast_src_length<
-                    Source, typename boost::enable_if<boost::is_integral<Source> >::type
+                    Source, typename std::enable_if<boost::detail::lcast::is_integral<Source>::value >::type
                 >
         {
             BOOST_STATIC_CONSTANT(std::size_t, value =
@@ -385,7 +388,7 @@ namespace boost {
         // sign + leading digit + decimal point + "e" + exponent sign == 5
         template<class Source>
         struct lcast_src_length<
-                Source, typename boost::enable_if<boost::is_float<Source> >::type
+                Source, typename std::enable_if<std::is_floating_point<Source>::value >::type
             >
         {
             static_assert(
@@ -404,7 +407,7 @@ namespace boost {
         template <class Source, class Target>
         struct lexical_cast_stream_traits {
             typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
-            typedef typename boost::remove_cv<src>::type            no_cv_src;
+            typedef typename std::remove_cv<src>::type            no_cv_src;
 
             typedef boost::detail::deduce_source_char<no_cv_src>                           deduce_src_char_metafunc;
             typedef typename deduce_src_char_metafunc::type           src_char_t;
@@ -415,13 +418,13 @@ namespace boost {
             >::type char_type;
 
 #if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            static_assert(!boost::is_same<char16_t, src_char_t>::value
-                                        && !boost::is_same<char16_t, target_char_t>::value,
+            static_assert(!std::is_same<char16_t, src_char_t>::value
+                                        && !std::is_same<char16_t, target_char_t>::value,
                 "Your compiler does not have full support for char16_t" );
 #endif
 #if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            static_assert(!boost::is_same<char32_t, src_char_t>::value
-                                        && !boost::is_same<char32_t, target_char_t>::value,
+            static_assert(!std::is_same<char32_t, src_char_t>::value
+                                        && !std::is_same<char32_t, target_char_t>::value,
                 "Your compiler does not have full support for char32_t" );
 #endif