passenger 6.2.1 → 6.2.2

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

@@ -0,0 +1,90 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_GENERATE_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_GENERATE_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>
+#include <boost/move/utility_core.hpp>
+
+namespace boost {
+namespace container {
+
+template <class FwdIt, class Sent, class Generator>
+void segmented_generate(FwdIt first, Sent last, Generator gen);
+
+namespace detail_algo {
+
+template <class FwdIt, class Sent, class Generator, class Tag, class Cat>
+ BOOST_CONTAINER_FORCEINLINE typename algo_enable_if_c<
+   !Tag::value || is_sentinel<Sent, FwdIt>::value>::type
+segmented_generate_dispatch(FwdIt first, const Sent last, Generator & BOOST_RESTRICT gen, Tag, Cat)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; first != last; ++first)
+      *first = gen();
+}
+
+template <class SegIter, class Generator, class Cat>
+void segmented_generate_dispatch
+   (SegIter first, SegIter last, Generator & BOOST_RESTRICT gen, 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 slast  = traits::segment(last);
+
+   if(sfirst == slast) {
+      (segmented_generate_dispatch)(traits::local(first), traits::local(last), gen, is_local_seg_t(), local_cat_t());
+   }
+   else {
+      (segmented_generate_dispatch)(traits::local(first), traits::end(sfirst), gen, is_local_seg_t(), local_cat_t());
+
+      for(++sfirst; sfirst != slast; ++sfirst)
+         (segmented_generate_dispatch)(traits::begin(sfirst), traits::end(sfirst), gen, is_local_seg_t(), local_cat_t());
+
+      (segmented_generate_dispatch)(traits::begin(sfirst), traits::local(last), gen, is_local_seg_t(), local_cat_t());
+   }
+}
+
+} // namespace detail_algo
+
+//! Assigns the result of successive calls to \c gen to each
+//! element in [first, last).
+//! Generator state is preserved across segment boundaries.
+template <class FwdIt, class Sent, class Generator>
+BOOST_CONTAINER_FORCEINLINE
+void segmented_generate(FwdIt first, Sent last, Generator gen)
+{
+   typedef segmented_iterator_traits<FwdIt> traits;
+   detail_algo::segmented_generate_dispatch
+      (first, last, gen, typename traits::is_segmented_iterator(), typename iterator_traits<FwdIt>::iterator_category());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_GENERATE_HPP

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

@@ -0,0 +1,162 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_GENERATE_N_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_GENERATE_N_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/iterators.hpp>
+#include <boost/container/detail/std_fwd.hpp>
+
+namespace boost {
+namespace container {
+
+template <class OutIt, class Size, class Generator>
+OutIt segmented_generate_n(OutIt first, Size count, Generator gen);
+
+namespace detail_algo {
+
+template <class OutIter, class Size, class Generator>
+BOOST_CONTAINER_FORCEINLINE
+segduo<OutIter, Size> generate_n_scan
+   ( OutIter first, OutIter last, Size count
+   , Generator &BOOST_RESTRICT gen, non_segmented_iterator_tag, const std::random_access_iterator_tag &)
+{
+   const Size range_sz = static_cast<Size>(last - first);
+
+   const Size length = count < (Size)range_sz ? count : (Size)range_sz;
+   count -= length;
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for (Size cnt = 0; cnt != length; ++first, ++cnt){
+      *first = gen();
+   }
+   return segduo<OutIter, Size>(first, count);
+}
+
+template <class OutIter, class Size, class Generator, class Cat>
+BOOST_CONTAINER_FORCEINLINE
+segduo<OutIter, Size> generate_n_scan
+   (OutIter first, OutIter last, Size count, Generator &BOOST_RESTRICT gen, non_segmented_iterator_tag, const Cat &)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for (; count > 0 && first != last; ++first, --count)
+      *first = gen();
+
+   return segduo<OutIter, Size>(first, count);
+}
+
+template <class SegIt, class Size, class Generator, class Cat>
+segduo<SegIt, Size> generate_n_scan(SegIt first, SegIt last, Size count, Generator& BOOST_RESTRICT gen, segmented_iterator_tag, const Cat &)
+{
+   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 typename iterator_traits<local_iterator>::iterator_category                 local_cat_t;
+
+   segment_iterator       scur  = traits::segment(first);
+   segment_iterator const slast = traits::segment(last);
+
+   if(scur == slast) {
+      const local_iterator ll = traits::local(last);
+      const segduo<local_iterator, Size> r = (generate_n_scan)(traits::local(first), ll, count, gen, is_local_seg_t(), local_cat_t());
+      return segduo<SegIt, Size>((r.first != ll) ? traits::compose(scur, r.first) : last, r.second);
+   }
+   else {
+      segduo<local_iterator, Size> r = generate_n_scan(traits::local(first), traits::end(scur), count, gen, is_local_seg_t(), local_cat_t());
+      count = r.second;
+      if (!count)
+         return segduo<SegIt, Size>(traits::compose(scur, r.first), count);
+
+      for (++scur; scur != slast; ++scur) {
+         r = generate_n_scan(traits::begin(scur), traits::end(scur), count, gen, is_local_seg_t(), local_cat_t());
+         count = r.second;
+         if (!count)
+            return segduo<SegIt, Size>(traits::compose(scur, r.first), count);
+      }
+      const local_iterator ll = traits::local(last);
+      r = generate_n_scan(traits::begin(slast), ll, count, gen, is_local_seg_t(), local_cat_t());
+      return segduo<SegIt, Size>((r.first != ll) ? traits::compose(scur, r.first) : last, r.second);
+   }
+}
+
+template <class SegIter, class Size, class Generator>
+SegIter segmented_generate_n_ref
+   (SegIter first, Size count, Generator& BOOST_RESTRICT gen, 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;
+   typedef typename iterator_traits<local_iterator>::iterator_category local_cat_t;
+
+   segment_iterator scur = traits::segment(first);
+   local_iterator   lcur;
+
+   {
+      const segduo<local_iterator, Size> r = generate_n_scan(traits::local(first), traits::end(scur), count, gen, is_local_seg_t(), local_cat_t());
+      lcur  = r.first;
+      count = r.second;
+   }
+
+   if(count){
+      ++scur;
+      while(1) {
+         const segduo<local_iterator, Size> r = generate_n_scan(traits::begin(scur), traits::end(scur), count, gen, is_local_seg_t(), local_cat_t());
+         lcur  = r.first;
+         count = r.second;
+         if(count == 0)
+            break;
+         ++scur;
+      }
+   }
+   return traits::compose(scur, lcur);
+}
+
+template <class OutIt, class Size, class Generator>
+OutIt segmented_generate_n_ref
+   (OutIt first, Size count, Generator& BOOST_RESTRICT gen, non_segmented_iterator_tag)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; count > 0; ++first, --count)
+      *first = gen();
+   return first;
+}
+
+} // namespace detail_algo
+
+//! Assigns the result of successive calls to \c gen to the first
+//! \c count elements starting at \c first. Generator state is
+//! preserved across segment boundaries.
+//! Returns an iterator past the last generated element.
+template <class OutIt, class Size, class Generator>
+BOOST_CONTAINER_FORCEINLINE
+OutIt segmented_generate_n(OutIt first, Size count, Generator gen)
+{
+   typedef segmented_iterator_traits<OutIt> traits;
+   return detail_algo::segmented_generate_n_ref(first, count, gen,
+      typename traits::is_segmented_iterator());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_GENERATE_N_HPP

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

@@ -0,0 +1,46 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_IS_PARTITIONED_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_IS_PARTITIONED_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_find_if_not.hpp>
+#include <boost/container/experimental/segmented_none_of.hpp>
+
+namespace boost {
+namespace container {
+
+//! Returns \c true if all elements satisfying \c pred appear before
+//! all elements that do not, i.e. the range [first, last) is
+//! partitioned with respect to \c pred.
+//! Exploits segmentation when available.
+template <class InpIter, class Sent, class Pred>
+inline bool segmented_is_partitioned(InpIter first, Sent last, Pred pred)
+{
+   first = (segmented_find_if_not)(first, last, pred);
+   return (segmented_none_of)(first, last, pred);
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_IS_PARTITIONED_HPP

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

@@ -0,0 +1,49 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_IS_SORTED_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_IS_SORTED_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_is_sorted_until.hpp>
+
+namespace boost {
+namespace container {
+
+//! Returns true if [first, last) is sorted according to \c comp.
+template <class FwdIt, class Sent, class Comp>
+BOOST_CONTAINER_FORCEINLINE
+bool segmented_is_sorted(FwdIt first, Sent last, Comp comp)
+{
+   return (segmented_is_sorted_until)(first, last, comp) == last;
+}
+
+//! Returns true if [first, last) is sorted using operator<.
+template <class FwdIt, class Sent>
+BOOST_CONTAINER_FORCEINLINE
+bool segmented_is_sorted(FwdIt first, Sent last)
+{
+   return (segmented_is_sorted_until)(first, last) == last;
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_IS_SORTED_HPP

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

@@ -0,0 +1,169 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_IS_SORTED_UNTIL_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_IS_SORTED_UNTIL_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 {
+
+namespace detail_algo {
+
+// Recursive dispatch for `segmented_is_sorted_until`.
+//
+// Cross-segment state is carried by value and returned in segduo<Iter, DeepIt>:
+//   - `prev`      : iterator (of the deepest non-segmented local type) pointing
+//                   at the most recently examined element.
+//
+// All sorted_until_rec overloads return segduo<Iter, DeepIt> where .first is
+// the result iterator and .second is the updated prev value.  Passing prev by
+// value instead of by reference avoids pointer aliasing and lets the compiler
+// keep prev in a register throughout the inner loop.
+
+// (1) Non-segmented base case.
+//     At this level FwdIt == DeepIt (the deepest type computed from the top).
+template <class FwdIt, class Sent, class Comp, class DeepIt, class Cat>
+BOOST_CONTAINER_FORCEINLINE
+segduo<FwdIt, DeepIt> sorted_until_rec
+   (FwdIt first, Sent last, Comp comp,
+    DeepIt prev, const non_segmented_iterator_tag &, Cat)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for (; first != last; ++first) {
+      if (comp(*first, *prev))
+         break;
+      prev = detail_algo::deepest_local_iterator<FwdIt>::get(first);
+   }
+   return segduo<FwdIt, DeepIt>(first, prev);
+}
+
+// (2) Segmented iterator with a heterogeneous sentinel as end.
+//     Cannot locate `last`'s segment, so falls back to a simple linear loop.
+template <class SegIter, class Sent, class Comp, class DeepIt, class Tag, class Cat>
+BOOST_CONTAINER_FORCEINLINE
+typename algo_enable_if_c< is_sentinel<Sent, SegIter>::value
+                         , segduo<SegIter, DeepIt> >::type
+sorted_until_rec
+   (SegIter first, Sent last, Comp comp,
+    DeepIt prev, const Tag &, const Cat &cat)
+{
+   return sorted_until_rec
+      (first, last, comp, prev, non_segmented_iterator_tag(), cat);
+}
+
+// (3) Segmented iterator with a matching segmented iterator as end.
+//     Recursive: decomposes the range and dispatches each sub-range back to
+//     `sorted_until_rec`, so recursive segmentation is exploited at every
+//     level.  `prev` is threaded by value through the segduo return type.
+template <class SegIter, class Comp, class DeepIt, class Cat>
+segduo<SegIter, DeepIt> sorted_until_rec
+   (SegIter first, SegIter last, Comp comp,
+    DeepIt prev,
+    const segmented_iterator_tag &, Cat)
+{
+   typedef segmented_iterator_traits<SegIter>                             traits;
+   typedef typename traits::segment_iterator                              segment_iterator;
+   typedef typename traits::local_iterator                                local_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;
+   typedef segduo<local_iterator, DeepIt>                                 local_result_t;
+
+   segment_iterator       sfirst = traits::segment(first);
+   const segment_iterator slast  = traits::segment(last);
+
+   if (sfirst == slast) {
+      const local_iterator ll = traits::local(last);
+      const local_result_t r = (sorted_until_rec)
+         (traits::local(first), ll, comp, prev, is_local_seg_t(), local_cat_t());
+      return segduo<SegIter, DeepIt>(traits::compose(sfirst, r.first), r.second);
+   }
+   else {
+      local_iterator le = traits::end(sfirst);
+      local_result_t r = (sorted_until_rec)
+         (traits::local(first), le, comp, prev, is_local_seg_t(), local_cat_t());
+      if (r.first != le)
+         return segduo<SegIter, DeepIt>(traits::compose(sfirst, r.first), r.second);
+
+      for (++sfirst; sfirst != slast; ++sfirst) {
+         le = traits::end(sfirst);
+         r = (sorted_until_rec)
+            (traits::begin(sfirst), le, comp, r.second, is_local_seg_t(), local_cat_t());
+         if (r.first != le)
+            return segduo<SegIter, DeepIt>(traits::compose(sfirst, r.first), r.second);
+      }
+      r = (sorted_until_rec)
+         (traits::begin(slast), traits::local(last), comp, r.second, is_local_seg_t(), local_cat_t());
+      return segduo<SegIter, DeepIt>(traits::compose(sfirst, r.first), r.second);
+   }
+}
+
+} // namespace detail_algo
+
+//! Returns an iterator to the first element that is less than its predecessor
+//! in [first, last), using \c comp for comparison.
+//! Returns \c last if the range is sorted.
+template <class FwdIt, class Sent, class Comp>
+inline
+FwdIt segmented_is_sorted_until(FwdIt first, Sent last, Comp comp)
+{
+   if (first == last)
+      return first;
+
+   typedef segmented_iterator_traits<FwdIt>           traits;
+   typedef detail_algo::deepest_local_iterator<FwdIt> deep_it_helper;
+   typedef typename deep_it_helper::type              deep_it;
+
+   deep_it prev = deep_it_helper::get(first);
+   return detail_algo::sorted_until_rec
+      (++first, last, comp, prev,
+         typename traits::is_segmented_iterator(),
+         typename iterator_traits<FwdIt>::iterator_category()).first;
+}
+
+//! Returns an iterator to the first element that is less than its predecessor
+//! in [first, last), using operator<.
+//! Returns \c last if the range is sorted.
+template <class FwdIt, class Sent>
+inline
+FwdIt segmented_is_sorted_until(FwdIt first, Sent last)
+{
+   if (first == last)
+      return first;
+
+   typedef segmented_iterator_traits<FwdIt>           traits;
+   typedef detail_algo::deepest_local_iterator<FwdIt> deep_it_helper;
+   typedef typename deep_it_helper::type              deep_it;
+
+   deep_it prev = deep_it_helper::get(first);
+   return detail_algo::sorted_until_rec
+      (++first, last, detail_algo::segmented_default_less(), prev,
+         typename traits::is_segmented_iterator(),
+         typename iterator_traits<FwdIt>::iterator_category()).first;
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_IS_SORTED_UNTIL_HPP