passenger 6.2.1 → 6.2.2

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

@@ -367,6 +367,9 @@ class slist_impl
    //! <b>Complexity</b>: Linear to the number of elements in the list, if
    //!   it's a safe-mode or auto-unlink value. Otherwise constant.
    ~slist_impl()
+   #if defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+      requires (ValueTraits::link_mode != normal_link)
+   #endif
    {
       BOOST_IF_CONSTEXPR(is_safe_autounlink<ValueTraits::link_mode>::value){
          this->clear();
@@ -374,6 +377,11 @@ class slist_impl
       }
    }
 
+   #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+   //Default destructor for normal links (allows conditional triviality)
+   ~slist_impl() requires (ValueTraits::link_mode == normal_link) = default;
+   #endif
+
    //! <b>Effects</b>: Erases all the elements of the container.
    //!
    //! <b>Throws</b>: Nothing.
@@ -820,7 +828,9 @@ class slist_impl
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
       node_ptr prev_n(prev_p.pointed_node());
       node_algorithms::link_after(prev_n, n);
-      if(cache_last && (this->get_last_node() == prev_n)){
+
+      BOOST_IF_CONSTEXPR(cache_last)
+      if(this->get_last_node() == prev_n){
          this->set_last_node(n);
       }
       this->priv_size_traits().increment();
@@ -852,7 +862,8 @@ class slist_impl
          prev_n = n;
       }
       //Now fix special cases if needed
-      if(cache_last && (this->get_last_node() == prev_p.pointed_node())){
+      BOOST_IF_CONSTEXPR(cache_last)
+      if(this->get_last_node() == prev_p.pointed_node()){
          this->set_last_node(prev_n);
       }
       BOOST_IF_CONSTEXPR(constant_time_size){
@@ -1048,7 +1059,9 @@ class slist_impl
       ++it;
       node_ptr prev_n(prev.pointed_node());
       node_algorithms::unlink_after(prev_n);
-      if(cache_last && (to_erase == this->get_last_node())){
+
+      BOOST_IF_CONSTEXPR(cache_last)
+      if(to_erase == this->get_last_node()){
          this->set_last_node(prev_n);
       }
       BOOST_IF_CONSTEXPR(safemode_or_autounlink)
@@ -1135,7 +1148,9 @@ class slist_impl
          disposer(priv_value_traits().to_value_ptr(to_erase));
          this->priv_size_traits().decrement();
       }
-      if(cache_last && (node_traits::get_next(bfp) == this->get_end_node())){
+
+      BOOST_IF_CONSTEXPR(cache_last)
+      if(node_traits::get_next(bfp) == this->get_end_node()){
          this->set_last_node(bfp);
       }
       return l.unconst();
@@ -1576,7 +1591,8 @@ class slist_impl
    //! <b>Note</b>: Iterators and references are not invalidated
    void reverse() BOOST_NOEXCEPT
    {
-      if(cache_last && !this->empty()){
+      BOOST_IF_CONSTEXPR(cache_last)
+      if(!this->empty()){
          this->set_last_node(node_traits::get_next(this->get_root_node()));
       }
       this->priv_reverse(detail::bool_<linear>());
@@ -1592,8 +1608,8 @@ class slist_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid. This function is
    //!   linear time: it performs exactly size() comparisons for equality.
-   void remove(const_reference value) BOOST_NOEXCEPT
-   {  this->remove_if(detail::equal_to_value<const_reference>(value));  }
+   size_type remove(const_reference value) BOOST_NOEXCEPT
+   {  return this->remove_if(detail::equal_to_value<const_reference>(value));  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1607,8 +1623,8 @@ class slist_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
-   void remove_and_dispose(const_reference value, Disposer disposer) BOOST_NOEXCEPT
-   {  this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer);  }
+   size_type remove_and_dispose(const_reference value, Disposer disposer) BOOST_NOEXCEPT
+   {  return this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer);  }
 
    //! <b>Effects</b>: Removes all the elements for which a specified
    //!   predicate is satisfied. No destructors are called.
@@ -1620,7 +1636,7 @@ class slist_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Pred>
-   void remove_if(Pred pred)
+   size_type remove_if(Pred pred)
    {
       const node_ptr bbeg = this->get_root_node();
       typename node_algorithms::stable_partition_info info;
@@ -1634,6 +1650,7 @@ class slist_impl
       this->erase_after( const_iterator(bbeg, this->priv_value_traits_ptr())
                        , const_iterator(info.beg_2st_partition, this->priv_value_traits_ptr())
                        , info.num_1st_partition);
+      return info.num_1st_partition;
    }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
@@ -1649,7 +1666,7 @@ class slist_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Pred, class Disposer>
-   void remove_and_dispose_if(Pred pred, Disposer disposer)
+   size_type remove_and_dispose_if(Pred pred, Disposer disposer)
    {
       const node_ptr bbeg = this->get_root_node();
       typename node_algorithms::stable_partition_info info;
@@ -1663,24 +1680,29 @@ class slist_impl
       this->erase_after_and_dispose( const_iterator(bbeg, this->priv_value_traits_ptr())
                                    , const_iterator(info.beg_2st_partition, this->priv_value_traits_ptr())
                                    , disposer);
+      return info.num_1st_partition;
    }
 
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that are equal from the list. No destructors are called.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If operator== throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons calls to pred()).
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
-   void unique()
-   {  this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer());  }
+   size_type unique()
+   {  return this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer());  }
 
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that satisfy some binary predicate from the list.
    //!   No destructors are called.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If the predicate throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons.
@@ -1688,8 +1710,8 @@ class slist_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class BinaryPredicate>
-   void unique(BinaryPredicate pred)
-   {  this->unique_and_dispose(pred, detail::null_disposer());  }
+   size_type unique(BinaryPredicate pred)
+   {  return this->unique_and_dispose(pred, detail::null_disposer());  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1697,6 +1719,8 @@ class slist_impl
    //!   elements that satisfy some binary predicate from the list.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
+   //! <b>Returns</b>: The number of removed elements.
+   //!
    //! <b>Throws</b>: If operator== throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons.
@@ -1704,8 +1728,8 @@ class slist_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
-   void unique_and_dispose(Disposer disposer)
-   {  this->unique(value_equal<value_type>(), disposer);  }
+   size_type unique_and_dispose(Disposer disposer)
+   {  return this->unique_and_dispose(value_equal<value_type>(), disposer);  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1720,16 +1744,19 @@ class slist_impl
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class BinaryPredicate, class Disposer>
-   void unique_and_dispose(BinaryPredicate pred, Disposer disposer)
+   size_type unique_and_dispose(BinaryPredicate pred, Disposer disposer)
    {
       const_iterator end_n(this->cend());
       const_iterator bcur(this->cbegin());
+      size_type n = 0;
+
       if(bcur != end_n){
          const_iterator cur(bcur);
          ++cur;
          while(cur != end_n) {
             if (pred(*bcur, *cur)){
                cur = this->erase_after_and_dispose(bcur, disposer);
+               ++n;
             }
             else{
                bcur = cur;
@@ -1740,6 +1767,7 @@ class slist_impl
             this->set_last_node(bcur.pointed_node());
          }
       }
+      return n;
    }
 
    //! <b>Requires</b>: `value` must be a reference to a value inserted in an instance of this container type.
@@ -1964,7 +1992,8 @@ class slist_impl
 
    friend bool operator==(const slist_impl &x, const slist_impl &y)
    {
-      if(constant_time_size && x.size() != y.size()){
+      BOOST_IF_CONSTEXPR(constant_time_size)
+      if(x.size() != y.size()){
          return false;
       }
       return ::boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend());
@@ -1991,7 +2020,8 @@ class slist_impl
    private:
    void priv_splice_after(node_ptr prev_pos_n, slist_impl &x, node_ptr before_f_n, node_ptr before_l_n)
    {
-      if (cache_last && (before_f_n != before_l_n)){
+      BOOST_IF_CONSTEXPR(cache_last)
+      if(before_f_n != before_l_n){
          if(prev_pos_n == this->get_last_node()){
             this->set_last_node(before_l_n);
          }
@@ -2025,7 +2055,10 @@ class slist_impl
    void priv_shift_backwards(size_type n, detail::bool_<false>)
    {
       node_ptr l = node_algorithms::move_forward(this->get_root_node(), (std::size_t)n);
-      if(cache_last && l){
+      (void)l;
+
+      BOOST_IF_CONSTEXPR(cache_last)
+      if(l){
          this->set_last_node(l);
       }
    }
@@ -2046,7 +2079,10 @@ class slist_impl
    void priv_shift_forward(size_type n, detail::bool_<false>)
    {
       node_ptr l = node_algorithms::move_backwards(this->get_root_node(), (std::size_t)n);
-      if(cache_last && l){
+      (void)l;
+
+      BOOST_IF_CONSTEXPR(cache_last)
+      if(l){
          this->set_last_node(l);
       }
    }

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

@@ -386,9 +386,11 @@ class unordered_set_impl
 
    friend bool operator==(const unordered_set_impl &x, const unordered_set_impl &y)
    {
-      if(table_type::constant_time_size && x.size() != y.size()){
+      BOOST_IF_CONSTEXPR(table_type::constant_time_size)
+      if(x.size() != y.size()){
          return false;
       }
+
       //Find each element of x in y
       for (const_iterator ix = x.cbegin(), ex = x.cend(), ey = y.cend(); ix != ex; ++ix){
          const_iterator iy = y.find(key_of_value()(*ix));

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

@@ -7,7 +7,10 @@
 #ifndef BOOST_ITERATOR_ADVANCE_HPP
 #define BOOST_ITERATOR_ADVANCE_HPP
 
+#include <type_traits>
+
 #include <boost/config.hpp>
+#include <boost/iterator/is_iterator.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 
 namespace boost {
@@ -56,7 +59,8 @@ inline BOOST_CXX14_CONSTEXPR void advance_impl(RandomAccessIterator& it, Distanc
 namespace advance_adl_barrier {
 
 template< typename InputIterator, typename Distance >
-inline BOOST_CXX14_CONSTEXPR void advance(InputIterator& it, Distance n)
+inline BOOST_CXX14_CONSTEXPR typename std::enable_if< is_iterator< InputIterator >::value >::type
+advance(InputIterator& it, Distance n)
 {
     detail::advance_impl(it, n, typename iterator_traversal< InputIterator >::type());
 }

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

@@ -1,4 +1,5 @@
 // Copyright (C) 2017 Michel Morin.
+// Copyright (C) 2026 Jeremy W. Murphy
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
@@ -7,7 +8,10 @@
 #ifndef BOOST_ITERATOR_DISTANCE_HPP
 #define BOOST_ITERATOR_DISTANCE_HPP
 
+#include <type_traits>
+
 #include <boost/config.hpp>
+#include <boost/iterator/is_iterator.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 
@@ -40,8 +44,10 @@ distance_impl(RandomAccessIterator first, RandomAccessIterator last, random_acce
 namespace distance_adl_barrier {
 
 template< typename SinglePassIterator >
-inline BOOST_CXX14_CONSTEXPR typename iterator_difference< SinglePassIterator >::type
-distance(SinglePassIterator first, SinglePassIterator last)
+inline BOOST_CXX14_CONSTEXPR typename std::enable_if<
+    is_iterator< SinglePassIterator >::value,
+    iterator_difference< SinglePassIterator >
+>::type::type distance(SinglePassIterator first, SinglePassIterator last)
 {
     return detail::distance_impl(first, last, typename iterator_traversal< SinglePassIterator >::type());
 }

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

@@ -139,10 +139,19 @@ struct is_iterator< volatile T > : public detail::is_iterator_impl< T >::type {}
 template< typename T >
 struct is_iterator< const volatile T > : public detail::is_iterator_impl< T >::type {};
 
+#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
+template< typename T >
+BOOST_INLINE_VARIABLE constexpr bool is_iterator_v = iterators::is_iterator< T >::value;
+#endif // !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
+
 } // namespace iterators
 
 using iterators::is_iterator;
 
+#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
+using iterators::is_iterator_v;
+#endif // !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
+
 } // namespace boost
 
 #endif // BOOST_ITERATOR_IS_ITERATOR_HPP_INCLUDED_

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-2025.
+// Copyright Antony Polukhin, 2011-2026.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,6 +18,11 @@
 #ifndef BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
 #define BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
 
+#include <boost/lexical_cast/detail/config.hpp>
+
+#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
+#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
@@ -26,9 +31,11 @@
 #include <exception>
 #include <typeinfo>
 #include <boost/throw_exception.hpp>
+#endif
 
 namespace boost
 {
+BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT
     // exception used to indicate runtime lexical_cast failure
     class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
     // workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0
@@ -80,6 +87,7 @@ namespace boost
         const type_info_t *target;
 #endif
     };
+BOOST_LEXICAL_CAST_END_MODULE_EXPORT
 
     namespace conversion { namespace detail {
 #ifdef BOOST_NO_TYPEID
@@ -97,4 +105,6 @@ namespace boost
 
 } // namespace boost
 
+#endif  // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
 #endif // BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP

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

@@ -1,4 +1,4 @@
-// Copyright Antony Polukhin, 2011-2025.
+// Copyright Antony Polukhin, 2011-2026.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -7,12 +7,18 @@
 #ifndef BOOST_LEXICAL_CAST_DETAIL_BUFFER_VIEW_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_BUFFER_VIEW_HPP
 
+#include <boost/lexical_cast/detail/config.hpp>
+
+#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
+#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
 #endif
 
 #include <iosfwd>
+#endif
 
 namespace boost { namespace conversion { namespace detail {
 
@@ -55,5 +61,7 @@ namespace boost { namespace conversion { namespace detail {
 
 }}}  // namespace boost::conversion::detail
 
+#endif  // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
 #endif // BOOST_LEXICAL_CAST_DETAIL_BUFFER_VIEW_HPP
 

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

@@ -0,0 +1,22 @@
+// Copyright Antony Polukhin, 2021-2026.
+//
+// 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_LEXICAL_CAST_DETAIL_CONFIG_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_CONFIG_HPP
+
+#ifdef BOOST_LEXICAL_CAST_INTERFACE_UNIT
+#   define BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT export {
+#   define BOOST_LEXICAL_CAST_END_MODULE_EXPORT }
+#else
+#   define BOOST_LEXICAL_CAST_BEGIN_MODULE_EXPORT
+#   define BOOST_LEXICAL_CAST_END_MODULE_EXPORT
+#endif
+
+#if defined(BOOST_USE_MODULES) && !defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+import boost.lexical_cast;
+#endif
+
+#endif  // #ifndef BOOST_LEXICAL_CAST_DETAIL_CONFIG_HPP

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-2025.
+// Copyright Antony Polukhin, 2011-2026.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,6 +18,11 @@
 #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
 
+#include <boost/lexical_cast/detail/config.hpp>
+
+#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
+#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
@@ -27,15 +32,11 @@
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
 
+#include <array>
 #include <cstddef>
 #include <string>
 #include <type_traits>
 #include <boost/limits.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>
 
@@ -43,9 +44,14 @@
 #include <string_view>
 #endif
 
-#include <boost/lexical_cast/detail/buffer_view.hpp>
 #include <boost/container/container_fwd.hpp>
 
+#endif  // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
+
+#include <boost/lexical_cast/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/buffer_view.hpp>
 #include <boost/lexical_cast/detail/converter_lexical_streams.hpp>
 
 namespace boost {
@@ -479,5 +485,7 @@ namespace boost {
 
 #undef BOOST_LCAST_NO_WCHAR_T
 
+#endif  // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
 #endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
 

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

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2025.
+// Copyright Antony Polukhin, 2011-2026.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,12 +18,16 @@
 #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
 
+#include <boost/lexical_cast/detail/config.hpp>
+
+#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
+#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
 #endif
 
-
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
@@ -33,9 +37,8 @@
 #include <cstring>
 #include <cstdio>
 #include <type_traits>
+
 #include <boost/limits.hpp>
-#include <boost/detail/lcast_precision.hpp>
-#include <boost/lexical_cast/detail/type_traits.hpp>
 #include <boost/config/workaround.hpp>
 #include <boost/core/snprintf.hpp>
 
@@ -58,21 +61,28 @@
 #include <sstream>
 #endif
 
-#include <boost/lexical_cast/detail/buffer_view.hpp>
-#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
-#include <boost/lexical_cast/detail/lcast_unsigned_converters.hpp>
-#include <boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp>
-#include <boost/lexical_cast/detail/inf_nan.hpp>
-
-#include <istream>
 
 #include <array>
+#ifndef BOOST_NO_CWCHAR
+#   include <cwchar>
+#endif
+#include <istream>
 
 #include <boost/container/container_fwd.hpp>
 #ifndef BOOST_NO_CWCHAR
 #   include <cwchar>
 #endif
 
+#endif  // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
+
+#include <boost/lexical_cast/detail/buffer_view.hpp>
+#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
+#include <boost/lexical_cast/detail/lcast_unsigned_converters.hpp>
+#include <boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp>
+#include <boost/lexical_cast/detail/inf_nan.hpp>
+#include <boost/lexical_cast/detail/lcast_precision.hpp>
+#include <boost/lexical_cast/detail/type_traits.hpp>
+
 // Forward declarations
 namespace boost {
     template<class T, std::size_t N>
@@ -747,5 +757,7 @@ namespace boost { namespace detail { namespace lcast {
 
 #undef BOOST_LCAST_NO_WCHAR_T
 
+#endif  // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
 #endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
 

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

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2025.
+// Copyright Antony Polukhin, 2011-2026.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,6 +18,11 @@
 #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
 
+#include <boost/lexical_cast/detail/config.hpp>
+
+#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
+#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
@@ -26,6 +31,9 @@
 #include <type_traits>
 #include <boost/core/cmath.hpp>
 #include <boost/limits.hpp>
+
+#endif  // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
+
 #include <boost/lexical_cast/detail/type_traits.hpp>
 
 namespace boost { namespace detail {
@@ -176,5 +184,7 @@ struct dynamic_num_converter_impl
 
 }} // namespace boost::detail
 
+#endif  // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
 #endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
 

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

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2025.
+// Copyright Antony Polukhin, 2011-2026.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,6 +18,11 @@
 #ifndef BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
 
+#include <boost/lexical_cast/detail/config.hpp>
+
+#if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
+#ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
@@ -32,6 +37,7 @@
 #include <boost/core/cmath.hpp>
 #include <cstddef>
 #include <cstring>
+#endif  // #ifndef BOOST_LEXICAL_CAST_INTERFACE_UNIT
 
 #include <boost/lexical_cast/detail/lcast_char_constants.hpp>
 
@@ -183,5 +189,7 @@ namespace boost {
 
 #undef BOOST_LCAST_NO_WCHAR_T
 
+#endif  // #if !defined(BOOST_USE_MODULES) || defined(BOOST_LEXICAL_CAST_INTERFACE_UNIT)
+
 #endif // BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP