passenger 6.2.1 → 6.2.2

data/src/cxx_supportlib/vendor-modified/boost/container/experimental/segmented_stable_partition.hpp

@@ -0,0 +1,153 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2025-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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_STABLE_PARTITION_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_STABLE_PARTITION_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/experimental/segmented_iterator_traits.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/container/detail/iterator.hpp>
+
+namespace boost {
+namespace container {
+
+template <class BidirIt, class Pred>
+BidirIt segmented_stable_partition(BidirIt first, BidirIt last, Pred pred);
+
+namespace detail_algo {
+
+template <class BidirIt, class T>
+BidirIt stable_partition_shift( BidirIt it, BidirIt result, T& tmp)
+{
+   BidirIt cur = it;
+   while(cur != result) {
+      BidirIt prev = cur; --prev;
+      *cur = boost::move(*prev);
+      cur = prev;
+   }
+   *result = boost::move(tmp);
+   return ++result;
+}
+
+// Composes a local iterator back to the outermost segmented iterator.
+// At the top level, identity_composer just returns the iterator as-is.
+// At each recursion level, chained_composer calls traits::compose to go
+// one level up, then delegates to the outer composer.
+template <class SegIter>
+struct sp_identity_composer
+{
+   typedef SegIter result_type;
+   BOOST_CONTAINER_FORCEINLINE result_type operator()(SegIter it) const { return it; }
+};
+
+template <class OuterComposer, class Traits>
+struct sp_chained_composer
+{
+   typedef typename OuterComposer::result_type result_type;
+   OuterComposer outer_;
+   typename Traits::segment_iterator seg_;
+
+   BOOST_CONTAINER_FORCEINLINE sp_chained_composer(OuterComposer o, typename Traits::segment_iterator s)
+      : outer_(o), seg_(s) {}
+
+   BOOST_CONTAINER_FORCEINLINE result_type operator()(typename Traits::local_iterator l) const
+   { return outer_(Traits::compose(seg_, l)); }
+};
+
+template <class FwdIt, class OuterIter, class Composer, class Pred>
+OuterIter stable_partition_scan(FwdIt first, FwdIt last, OuterIter result, Composer composer, Pred pred, non_segmented_iterator_tag)
+{
+   typedef typename boost::container::iterator_traits<OuterIter>::value_type value_type;
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; first != last; ++first) {
+      if(pred(*first)) {
+         value_type tmp = boost::move(*first);
+         OuterIter it = composer(first);
+         result = stable_partition_shift(it, result, tmp);
+      }
+   }
+   return result;
+}
+
+template <class SegIt, class OuterIter, class Composer, class Pred>
+OuterIter stable_partition_scan(SegIt first, SegIt last, OuterIter result,
+   Composer composer, Pred& pred, segmented_iterator_tag)
+{
+   typedef segmented_iterator_traits<SegIt>   traits;
+   typedef typename traits::local_iterator    local_iterator;
+   typedef typename traits::segment_iterator  segment_iterator;
+   typedef typename segmented_iterator_traits
+      <local_iterator>::is_segmented_iterator is_local_seg_t;
+
+   typedef sp_chained_composer<Composer, traits> composer_t;
+
+   segment_iterator       scur  = traits::segment(first);
+   segment_iterator const slast = traits::segment(last);
+   local_iterator         lcur  = traits::local(first);
+
+   if(scur == slast) {
+      result = stable_partition_scan(lcur, traits::local(last), result, composer_t(composer, scur), pred, is_local_seg_t());
+   }
+   else {
+      result = stable_partition_scan(lcur, traits::end(scur), result, composer_t(composer, scur), pred, is_local_seg_t());
+      for(++scur; scur != slast; ++scur) {
+         result = stable_partition_scan(traits::begin(scur), traits::end(scur), result, composer_t(composer, scur), pred, is_local_seg_t());
+      }
+      result = stable_partition_scan(traits::begin(scur), traits::local(last), result, composer_t(composer, scur), pred,is_local_seg_t());
+   }
+   return result;
+}
+
+template <class SegIter, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+SegIter segmented_stable_partition_dispatch (SegIter first, SegIter last, Pred pred, segmented_iterator_tag)
+{
+   return (stable_partition_scan)(first, last, first, sp_identity_composer<SegIter>(), pred, segmented_iterator_tag());
+}
+
+template <class BidirIt, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+BidirIt segmented_stable_partition_dispatch (BidirIt first, BidirIt last, Pred pred, non_segmented_iterator_tag)
+{
+   return (stable_partition_scan)(first, last, first, sp_identity_composer<BidirIt>(), pred, non_segmented_iterator_tag());
+}
+
+} // namespace detail_algo
+
+//! Note: This version is suboptimal only supports bidirectional iterators,
+//! as it relies on stable_partition_shift.
+//! 
+//! Reorders elements in [first, last) so that elements satisfying
+//! \c pred come before those that do not, preserving relative order
+//! within each group. Returns an iterator to the partition point.
+template <class BidirIt, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+BidirIt segmented_stable_partition(BidirIt first, BidirIt last, Pred pred)
+{
+   typedef segmented_iterator_traits<BidirIt> traits;
+   return detail_algo::segmented_stable_partition_dispatch
+      (first, last, pred, typename traits::is_segmented_iterator());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_STABLE_PARTITION_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/experimental/segmented_swap_ranges.hpp

@@ -0,0 +1,92 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2025-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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_SWAP_RANGES_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_SWAP_RANGES_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/experimental/segmented_iterator_traits.hpp>
+#include <boost/move/adl_move_swap.hpp>
+
+namespace boost {
+namespace container {
+
+template <class FwdIt1, class Sent, class FwdIt2>
+FwdIt2 segmented_swap_ranges(FwdIt1 first1, Sent last1, FwdIt2 first2);
+
+namespace detail_algo {
+
+
+template <class FwdIt1, class Sent, class FwdIt2, class Tag>
+typename algo_enable_if_c<
+   !Tag::value || is_sentinel<Sent, FwdIt1>::value, FwdIt2>::type
+segmented_swap_ranges_dispatch (FwdIt1 first1, Sent last1, FwdIt2 first2, Tag)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; first1 != last1; ++first1, ++first2) {
+      boost::adl_move_swap(*first1, *first2);
+   }
+   return first2;
+}
+
+template <class SegIter, class FwdIt2>
+FwdIt2 segmented_swap_ranges_dispatch (SegIter first1, SegIter last1, FwdIt2 first2, segmented_iterator_tag)
+{
+   typedef segmented_iterator_traits<SegIter>   traits;
+   typedef typename traits::local_iterator    local_iterator;
+   typedef typename traits::segment_iterator  segment_iterator;
+   typedef typename segmented_iterator_traits
+      <local_iterator>::is_segmented_iterator is_local_seg_t;
+
+   segment_iterator       sfirst = traits::segment(first1);
+   segment_iterator const slast  = traits::segment(last1);
+
+   if(sfirst == slast) {
+      first2 = (segmented_swap_ranges_dispatch)(traits::local(first1), traits::local(last1), first2, is_local_seg_t());
+   }
+   else {
+      first2 = (segmented_swap_ranges_dispatch)(traits::local(first1), traits::end(sfirst), first2, is_local_seg_t());
+
+      for(++sfirst; sfirst != slast; ++sfirst)
+         first2 = (segmented_swap_ranges_dispatch)(traits::begin(sfirst), traits::end(sfirst), first2, is_local_seg_t());
+
+      first2 = (segmented_swap_ranges_dispatch)(traits::begin(sfirst), traits::local(last1), first2, is_local_seg_t());
+   }
+   return first2;
+}
+
+} // namespace detail_algo
+
+//! Swaps elements in [first1, last1) with the range starting at \c first2.
+//! Returns an iterator past the last swapped element in the second range.
+//! Segmentation is exploited on the first range.
+template <class FwdIt1, class Sent, class FwdIt2>
+BOOST_CONTAINER_FORCEINLINE
+FwdIt2 segmented_swap_ranges(FwdIt1 first1, Sent last1, FwdIt2 first2)
+{
+   typedef segmented_iterator_traits<FwdIt1> traits;
+   return detail_algo::segmented_swap_ranges_dispatch
+      (first1, last1, first2, typename traits::is_segmented_iterator());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_SWAP_RANGES_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/experimental/segmented_transform.hpp

@@ -0,0 +1,93 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2025-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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_TRANSFORM_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_TRANSFORM_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/experimental/segmented_iterator_traits.hpp>
+#include <boost/container/detail/iterator.hpp>
+
+namespace boost {
+namespace container {
+
+template <class InIter, class Sent, class OutIter, class UnaryOp>
+OutIter segmented_transform(InIter first, Sent last, OutIter result, UnaryOp op);
+
+namespace detail_algo {
+
+template <class InIter, class Sent, class OutIter, class UnaryOp, class Tag, class Cat>
+BOOST_CONTAINER_FORCEINLINE
+typename algo_enable_if_c<
+   !Tag::value || is_sentinel<Sent, InIter>::value, OutIter>::type
+segmented_transform_dispatch
+   (InIter first, Sent last, OutIter result, UnaryOp op, Tag, Cat)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; first != last; ++first, ++result)
+      *result = op(*first);
+   return result;
+}
+
+template <class SegIter, class OutIter, class UnaryOp, class Cat>
+OutIter segmented_transform_dispatch
+   (SegIter first, SegIter last, OutIter result, UnaryOp op, segmented_iterator_tag, Cat)
+{
+   typedef segmented_iterator_traits<SegIter> traits;
+   typedef typename traits::local_iterator    local_iterator;
+   typedef typename traits::segment_iterator  segment_iterator;
+   typedef typename segmented_iterator_traits
+      <local_iterator>::is_segmented_iterator is_local_seg_t;
+   typedef typename iterator_traits<local_iterator>::iterator_category local_cat_t;
+
+   segment_iterator       sfirst = traits::segment(first);
+   segment_iterator const slast  = traits::segment(last);
+
+   if(sfirst == slast) {
+      return (segmented_transform_dispatch)(traits::local(first), traits::local(last), result, op, is_local_seg_t(), local_cat_t());
+   }
+   else {
+      result = (segmented_transform_dispatch)(traits::local(first), traits::end(sfirst), result, op, is_local_seg_t(), local_cat_t());
+
+      for(++sfirst; sfirst != slast; ++sfirst)
+         result = (segmented_transform_dispatch)(traits::begin(sfirst), traits::end(sfirst), result, op, is_local_seg_t(), local_cat_t());
+
+      return (segmented_transform_dispatch)(traits::begin(sfirst), traits::local(last), result, op, is_local_seg_t(), local_cat_t());
+   }
+}
+
+} // namespace detail_algo
+
+//! Applies \c op to each element in [first, last) and writes the result
+//! to the range beginning at \c result.
+//! Segmentation is exploited on the input range only.
+template <class InIter, class Sent, class OutIter, class UnaryOp>
+BOOST_CONTAINER_FORCEINLINE
+OutIter segmented_transform (InIter first, Sent last, OutIter result, UnaryOp op)
+{
+   typedef segmented_iterator_traits<InIter> traits;
+   return detail_algo::segmented_transform_dispatch
+      (first, last, result, op, typename traits::is_segmented_iterator(), typename iterator_traits<InIter>::iterator_category());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_TRANSFORM_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/experimental/wrapped_iterator.hpp

@@ -0,0 +1,142 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2025-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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_EXPERIMENTAL_WRAPPED_ITERATOR_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_WRAPPED_ITERATOR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/detail/iterator.hpp>
+
+namespace boost {
+namespace container {
+
+namespace detail_algo {
+
+template<class Category, class Iterator>
+struct wrapped_iter_category
+{  typedef Category type; };
+
+template<class Iterator>
+struct wrapped_iter_category<void, Iterator>
+{  typedef typename iterator_traits<Iterator>::iterator_category type; };
+
+} // namespace detail_algo
+
+//! Iterator adaptor that wraps an existing iterator and re-declares its
+//! \c iterator_category to \c Category.  All underlying iterator operations
+//! are forwarded; only the category seen by tag-dispatching algorithms changes.
+//!
+//! When \c Category is \c void, the wrapped iterator preserves the original
+//! \c iterator_category from \c iterator_traits<Iterator>.
+//!
+//! \tparam Iterator  The type of the wrapped iterator.
+//! \tparam Category  The iterator category tag declared by the wrapper
+//!   (\c std::forward_iterator_tag, \c std::bidirectional_iterator_tag,
+//!    \c std::random_access_iterator_tag, or \c void to keep the original).
+template<class Iterator, class Category = void>
+class wrapped_iterator
+{
+   Iterator m_it;
+
+public:
+   typedef typename iterator_traits<Iterator>::value_type      value_type;
+   typedef typename iterator_traits<Iterator>::difference_type  difference_type;
+   typedef typename iterator_traits<Iterator>::pointer          pointer;
+   typedef typename iterator_traits<Iterator>::reference        reference;
+   typedef typename detail_algo::wrapped_iter_category<Category, Iterator>::type iterator_category;
+
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator() BOOST_NOEXCEPT : m_it() {}
+   BOOST_CONTAINER_FORCEINLINE explicit wrapped_iterator(Iterator it) BOOST_NOEXCEPT : m_it(it) {}
+
+   BOOST_CONTAINER_FORCEINLINE operator Iterator () const BOOST_NOEXCEPT {  return m_it; }
+
+   // Forward operations
+   BOOST_CONTAINER_FORCEINLINE reference operator*()  const BOOST_NOEXCEPT {  return *m_it;    }
+   BOOST_CONTAINER_FORCEINLINE pointer   operator->() const BOOST_NOEXCEPT {  return &(*m_it); }
+
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator& operator++() BOOST_NOEXCEPT
+   {  ++m_it; return *this; }
+
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator operator++(int) BOOST_NOEXCEPT
+   {  wrapped_iterator tmp(*this); ++m_it; return tmp; }
+
+   // Bidirectional operations
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator& operator--() BOOST_NOEXCEPT
+   {  --m_it; return *this; }
+
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator operator--(int) BOOST_NOEXCEPT
+   {  wrapped_iterator tmp(*this); --m_it; return tmp; }
+
+   // Random-access operations
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator& operator+=(difference_type n) BOOST_NOEXCEPT
+   {  m_it += n; return *this; }
+
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator& operator-=(difference_type n) BOOST_NOEXCEPT
+   {  m_it -= n; return *this; }
+
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator operator+(difference_type n) const BOOST_NOEXCEPT
+   {  wrapped_iterator tmp(*this); tmp += n; return tmp; }
+
+   BOOST_CONTAINER_FORCEINLINE wrapped_iterator operator-(difference_type n) const BOOST_NOEXCEPT
+   {  wrapped_iterator tmp(*this); tmp -= n; return tmp; }
+
+   BOOST_CONTAINER_FORCEINLINE reference operator[](difference_type n) const BOOST_NOEXCEPT
+   {  return m_it[n]; }
+
+   BOOST_CONTAINER_FORCEINLINE friend wrapped_iterator operator+(difference_type n, const wrapped_iterator& x) BOOST_NOEXCEPT
+   {  wrapped_iterator tmp(x); tmp += n; return tmp; }
+
+   BOOST_CONTAINER_FORCEINLINE friend difference_type operator-(const wrapped_iterator& x, const wrapped_iterator& y) BOOST_NOEXCEPT
+   {  return x.m_it - y.m_it; }
+
+   // Comparisons
+   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const wrapped_iterator& x, const wrapped_iterator& y) BOOST_NOEXCEPT
+   {  return x.m_it == y.m_it; }
+
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const wrapped_iterator& x, const wrapped_iterator& y) BOOST_NOEXCEPT
+   {  return x.m_it != y.m_it; }
+
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<(const wrapped_iterator& x, const wrapped_iterator& y) BOOST_NOEXCEPT
+   {  return x.m_it < y.m_it; }
+
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const wrapped_iterator& x, const wrapped_iterator& y) BOOST_NOEXCEPT
+   {  return y < x; }
+
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const wrapped_iterator& x, const wrapped_iterator& y) BOOST_NOEXCEPT
+   {  return !(y < x); }
+
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const wrapped_iterator& x, const wrapped_iterator& y) BOOST_NOEXCEPT
+   {  return !(x < y); }
+};
+
+//! Factory function: wraps \c it in a \c wrapped_iterator with the given
+//! \c Category.  \c Iterator is deduced; \c Category must be specified
+//! explicitly, e.g.
+//! \code make_wrapped_iterator<std::forward_iterator_tag>(ra_iter) \endcode
+template<class Category, class Iterator>
+BOOST_CONTAINER_FORCEINLINE
+wrapped_iterator<Iterator, Category>
+   make_wrapped_iterator(Iterator it) BOOST_NOEXCEPT
+{  return wrapped_iterator<Iterator, Category>(it); }
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_WRAPPED_ITERATOR_HPP