passenger 6.2.1 → 6.2.2

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

@@ -0,0 +1,245 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_REVERSE_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_REVERSE_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>
+#include <boost/container/detail/iterator.hpp>
+
+namespace boost {
+namespace container {
+
+namespace detail_algo {
+
+//Same-segment reverse: simply a reverse loop with move-swaps. No segmentation
+template <class BidirIt, class Cat>
+BOOST_CONTAINER_FORCEINLINE
+void segmented_reverse_dispatch(BidirIt first, BidirIt last, non_segmented_iterator_tag, const Cat &)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   while(first != last && first != --last) {
+      boost::adl_move_swap(*first, *last);
+      ++first;
+   }
+}
+
+template <class RAIter>
+BOOST_CONTAINER_FORCEINLINE
+void segmented_reverse_dispatch(RAIter first, RAIter last, non_segmented_iterator_tag, const std::random_access_iterator_tag &)
+{
+   typedef typename iterator_traits<RAIter>::difference_type difference_type;
+   difference_type pairs = (last - first) / difference_type(2);
+
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; pairs; --pairs) {
+      --last;
+      boost::adl_move_swap(*first, *last);
+      ++first;
+   }
+}
+
+//////////////////////////////////////////////
+// segmented_reverse_disjoint_ranges: swaps elements between
+// [f, f_end) (forward) and [l_beg, l) (backward).
+// Returns segduo with the final positions of f and l.
+// At least one side is fully consumed on return.
+//////////////////////////////////////////////
+
+template <class It, class Cat>
+BOOST_CONTAINER_FORCEINLINE
+segduo<It, It> segmented_reverse_disjoint_ranges
+   (It f, It const f_end, It const l_beg, It l, non_segmented_iterator_tag, const Cat &)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   while (f != f_end && l != l_beg) {
+      --l;
+      boost::adl_move_swap(*f, *l);
+      ++f;
+   }
+   return segduo<It, It>(f, l);
+}
+
+template <class It>
+BOOST_CONTAINER_FORCEINLINE
+segduo<It, It> segmented_reverse_disjoint_ranges
+   (It f, It const f_end, It const l_beg, It l, non_segmented_iterator_tag, const std::random_access_iterator_tag &)
+{
+   typedef typename iterator_traits<It>::difference_type difference_type;
+
+   difference_type n_f = f_end - f;
+   difference_type n_l = l - l_beg;
+   difference_type n = n_f < n_l ? n_f : n_l;
+
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; n; --n) {
+      --l;
+      boost::adl_move_swap(*f, *l);
+      ++f;
+   }
+
+   return segduo<It, It>(f, l);
+}
+
+template <class It, class Cat>
+segduo<It, It> segmented_reverse_disjoint_ranges(It f, It f_end, It l_beg, It l, segmented_iterator_tag, const Cat&)
+{
+   typedef segmented_iterator_traits<It>        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;
+
+   //Nothing to swap here if a range is empty
+   if (f == f_end || l == l_beg)
+      return segduo<It, It>(f, l);
+
+   segment_iterator       fs     = traits::segment(f);
+   const segment_iterator fs_end = traits::segment(f_end);
+   local_iterator         fi     = traits::local(f);
+   local_iterator         fi_end = (fs == fs_end) ? traits::local(f_end) : traits::end(fs);
+
+   segment_iterator       ls     = traits::segment(l);
+   const segment_iterator ls_beg = traits::segment(l_beg);
+   local_iterator         li     = traits::local(l);
+   local_iterator         li_beg = (ls == ls_beg) ? traits::local(l_beg) : traits::begin(ls);
+
+   //At least one of the two sides is guaranteed to be fully consumed after this loop
+   //since the ranges are guaranteed not to overlap
+   while (true) {
+      //Reverse the front and back segments recursively
+      segduo<local_iterator, local_iterator> r =
+         segmented_reverse_disjoint_ranges(fi, fi_end, li_beg, li, is_local_seg_t(), local_cat_t());
+      fi = r.first;
+      li = r.second;
+
+      //Independent advancement of forward and backward segments since ranges do not to overlap
+
+      //Check if the forward segment was fully consumed
+      if (fi == fi_end) {
+         //Check if there are no more segments to advance on the forward side, in which case we are done
+         if (fs == fs_end)
+            return segduo<It, It>(f_end, traits::compose(ls, li));
+         //Advance the forward segment
+         ++fs;
+         fi = traits::begin(fs);
+         fi_end = (fs == fs_end) ? traits::local(f_end) : traits::end(fs);
+      }
+
+      //Check if the backward segment was fully consumed
+      if (li == li_beg) {
+         //Check if there are no more segments to retreat on the backward side, in which case we are done
+         if (ls == ls_beg)
+            return segduo<It, It>(traits::compose(fs, fi), l_beg);
+         //Retreat the backward segment
+         --ls;
+         li = traits::end(ls);
+         li_beg = (ls == ls_beg) ? traits::local(l_beg) : traits::begin(ls);
+      }
+   }
+}
+
+template <class SegIt, class Cat>
+void segmented_reverse_dispatch(SegIt first, SegIt last, segmented_iterator_tag, const Cat &)
+{
+   typedef segmented_iterator_traits<SegIt>     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;
+
+   segment_iterator sf = traits::segment(first);
+   segment_iterator sl = traits::segment(last);
+   local_iterator f_loc = traits::local(first);
+   local_iterator l_loc = traits::local(last);
+
+   if (sf != sl) {
+      local_iterator f_end = traits::end(sf);
+      local_iterator l_beg = traits::begin(sl);
+
+      while (true) {
+         segduo<local_iterator, local_iterator> r =
+            segmented_reverse_disjoint_ranges(f_loc, f_end, l_beg, l_loc, is_local_seg_t(), local_cat_t());
+         f_loc = r.first;
+         l_loc = r.second;
+
+         //Check if the backward side reached the end of its segment
+         if (l_loc == l_beg) {
+            //If both sides reached the end of their respective segments
+            //advance the forward segment and retreat the backward segment
+            if (f_loc == f_end) {
+               ++sf;
+               //If both segments were adjacent and we exhausted both, we are done
+               if (sf == sl)
+                  return;
+
+               f_loc = traits::begin(sf);
+               f_end = traits::end(sf);
+            }
+
+            --sl;
+            if (sf == sl) {
+               l_loc = f_end;
+               break;
+            }
+            l_beg = traits::begin(sl);
+            l_loc = traits::end(sl);
+         }
+         else {   //The forward side reached the end of its segment
+            ++sf;
+            if (sf == sl) {
+               f_loc = l_beg;
+               break;
+            }
+            f_loc = traits::begin(sf);
+            f_end = traits::end(sf);
+         }
+      }
+   }
+   //Final reverse loop within the final segment
+   segmented_reverse_dispatch(f_loc, l_loc, is_local_seg_t(), local_cat_t());
+}
+
+} // namespace detail_algo
+
+//! Reverses the order of elements in [first, last).
+//! When the iterator is segmented, exploits segmentation on both
+//! the forward and backward sides to reduce per-element overhead.
+template <class BidirIter>
+BOOST_CONTAINER_FORCEINLINE
+void segmented_reverse(BidirIter first, BidirIter last)
+{
+   typedef segmented_iterator_traits<BidirIter> traits;
+   detail_algo::segmented_reverse_dispatch
+      ( first, last
+      , typename traits::is_segmented_iterator()
+      , typename iterator_traits<BidirIter>::iterator_category());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_REVERSE_HPP

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

@@ -0,0 +1,229 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_REVERSE_COPY_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_REVERSE_COPY_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 BidirIter, class OutIter>
+OutIter segmented_reverse_copy(BidirIter first, BidirIter last, OutIter result);
+
+namespace detail_algo {
+
+//////////////////////////////////////////////////////////////////////////////
+// Bounded destination helper: reverse-copies from [first, last) into
+// [dst_first, dst_last), reading backward from last toward first,
+// writing forward into dst.
+// Returns segduo<BidirIter, DstIter> where .first is the updated source
+// read position (last, moved backward) and .second is the updated dst.
+// When dst_last is unreachable_sentinel_t the destination-full check
+// is optimised away, giving the same code as an unbounded loop.
+//////////////////////////////////////////////////////////////////////////////
+
+template <class BidirIter, class DstIter, class DstSent, class DstTag, class SrcCat>
+BOOST_CONTAINER_FORCEINLINE typename algo_enable_if_c<!DstTag::value, segduo<BidirIter, DstIter> >::type
+segmented_reverse_copy_dst_bounded
+   (BidirIter first, BidirIter last, DstIter dst_first, DstSent dst_last, DstTag, SrcCat)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   while(first != last) {
+      if(dst_first == dst_last)
+         goto out_path;
+      --last;
+      *dst_first = *last;
+      ++dst_first;
+   }
+   out_path:
+   return segduo<BidirIter, DstIter>(last, dst_first);
+}
+
+template <class RASrcIter, class RADstIter>
+BOOST_CONTAINER_FORCEINLINE
+typename iterator_enable_if_tag
+   <RADstIter, std::random_access_iterator_tag, segduo<RASrcIter, RADstIter> >::type
+segmented_reverse_copy_dst_bounded
+   (RASrcIter first, RASrcIter last, RADstIter dst_first, RADstIter dst_last,
+    const non_segmented_iterator_tag &, const std::random_access_iterator_tag &src_tag)
+{
+   typedef typename iterator_traits<RASrcIter>::difference_type difference_type;
+   const difference_type src_n = last - first;
+   const difference_type dst_n = difference_type(dst_last - dst_first);
+   const difference_type n = src_n < dst_n ? src_n : dst_n;
+   return (segmented_reverse_copy_dst_bounded)(last - n, last, dst_first, unreachable_sentinel_t(),
+      non_segmented_iterator_tag(), src_tag);
+}
+
+template <class BidirIter, class SegDstIter, class SrcCat>
+segduo<BidirIter, SegDstIter> segmented_reverse_copy_dst_bounded
+   (BidirIter first, BidirIter last, SegDstIter dst_first, SegDstIter dst_last,
+    segmented_iterator_tag, SrcCat)
+{
+   typedef segmented_iterator_traits<SegDstIter>  dst_traits;
+   typedef typename dst_traits::local_iterator    dst_local_iterator;
+   typedef typename dst_traits::segment_iterator  dst_segment_iterator;
+   typedef typename segmented_iterator_traits<dst_local_iterator>::is_segmented_iterator dst_is_local_seg_t;
+
+   dst_segment_iterator       sfirst = dst_traits::segment(dst_first);
+   const dst_segment_iterator slast  = dst_traits::segment(dst_last);
+
+   if(sfirst == slast) {
+      segduo<BidirIter, dst_local_iterator> r = (segmented_reverse_copy_dst_bounded)
+         (first, last, dst_traits::local(dst_first), dst_traits::local(dst_last), dst_is_local_seg_t(), SrcCat());
+      return segduo<BidirIter, SegDstIter>(r.first, dst_traits::compose(sfirst, r.second));
+   }
+   else {
+      segduo<BidirIter, dst_local_iterator> r = (segmented_reverse_copy_dst_bounded)
+         (first, last, dst_traits::local(dst_first), dst_traits::end(sfirst), dst_is_local_seg_t(), SrcCat());
+      last = r.first;
+      if(first == last)
+         return segduo<BidirIter, SegDstIter>(last, dst_traits::compose(sfirst, r.second));
+
+      for(++sfirst; sfirst != slast; ++sfirst) {
+         r = (segmented_reverse_copy_dst_bounded)
+            (first, last, dst_traits::begin(sfirst), dst_traits::end(sfirst), dst_is_local_seg_t(), SrcCat());
+         last = r.first;
+         if(first == last)
+            return segduo<BidirIter, SegDstIter>(last, dst_traits::compose(sfirst, r.second));
+      }
+
+      r = (segmented_reverse_copy_dst_bounded)
+         (first, last, dst_traits::begin(slast), dst_traits::local(dst_last), dst_is_local_seg_t(), SrcCat());
+      return segduo<BidirIter, SegDstIter>(r.first, dst_traits::compose(sfirst, r.second));
+   }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Destination dispatch: routes to bounded helper.
+// Non-segmented destination: single unbounded call (unreachable_sentinel_t).
+// Segmented destination: loop over destination segments, bounded per segment.
+//////////////////////////////////////////////////////////////////////////////
+
+template <class BidirIter, class DstIter, class Cat>
+BOOST_CONTAINER_FORCEINLINE DstIter segmented_reverse_copy_dst_dispatch
+   (BidirIter first, BidirIter last, DstIter result,
+    const non_segmented_iterator_tag &, Cat)
+{
+   return (segmented_reverse_copy_dst_bounded)
+      (first, last, result, unreachable_sentinel_t(), non_segmented_iterator_tag(), Cat()).second;
+}
+
+template <class BidirIter, class SegDstIter, class Cat>
+SegDstIter segmented_reverse_copy_dst_dispatch
+   (BidirIter first, BidirIter last, SegDstIter result,
+    const segmented_iterator_tag &, Cat)
+{
+   typedef segmented_iterator_traits<SegDstIter>  dst_traits;
+   typedef typename dst_traits::local_iterator    dst_local_iterator;
+   typedef typename dst_traits::segment_iterator  dst_segment_iterator;
+   typedef typename segmented_iterator_traits<dst_local_iterator>::is_segmented_iterator dst_is_local_seg_t;
+
+   if(first == last)
+      return result;
+
+   dst_segment_iterator dst_seg   = dst_traits::segment(result);
+   dst_local_iterator   dst_local = dst_traits::local(result);
+
+   while(1) {
+      const dst_local_iterator dst_end = dst_traits::end(dst_seg);
+      const segduo<BidirIter, dst_local_iterator> r = (segmented_reverse_copy_dst_bounded)
+         (first, last, dst_local, dst_end, dst_is_local_seg_t(), Cat());
+      last = r.first;
+      if(first != last) {
+         ++dst_seg;
+         dst_local = dst_traits::begin(dst_seg);
+      }
+      else
+         return dst_traits::compose(dst_seg, r.second);
+   }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Source dispatch: walks the source (read pointer) segments in reverse
+//////////////////////////////////////////////////////////////////////////////
+
+template <class BidirIter, class OutIter, class Tag, class Cat>
+BOOST_CONTAINER_FORCEINLINE 
+typename algo_enable_if_c<!Tag::value, OutIter>::type
+   segmented_reverse_copy_dispatch(BidirIter first, BidirIter last, OutIter result, Tag, Cat)
+{
+#if !defined(BOOST_CONTAINER_DISABLE_MULTI_SEGMENTED_ALGO)
+   typedef segmented_iterator_traits<OutIter> dst_traits;
+   return (segmented_reverse_copy_dst_dispatch)
+      (first, last, result, typename dst_traits::is_segmented_iterator(), Cat());
+#else
+   return (segmented_reverse_copy_dst_dispatch)
+      (first, last, result, non_segmented_iterator_tag(), Cat());
+#endif
+}
+
+template <class SegIter, class OutIter, class Cat>
+OutIter segmented_reverse_copy_dispatch
+   (SegIter first, SegIter last, OutIter result, 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 const sfirst = traits::segment(first);
+   segment_iterator       slast  = traits::segment(last);
+
+   if(sfirst == slast) {
+      return (segmented_reverse_copy_dispatch)(traits::local(first), traits::local(last), result, is_local_seg_t(), local_cat_t());
+   }
+   else {
+      result = (segmented_reverse_copy_dispatch)(traits::begin(slast), traits::local(last), result, is_local_seg_t(), local_cat_t());
+
+      for (--slast; slast != sfirst; --slast)
+         result = (segmented_reverse_copy_dispatch)(traits::begin(slast), traits::end(slast), result, is_local_seg_t(), local_cat_t());
+
+      return (segmented_reverse_copy_dispatch)(traits::local(first), traits::end(sfirst), result, is_local_seg_t(), local_cat_t());
+   }
+}
+
+} // namespace detail_algo
+
+//! Copies elements from [first, last) to the range beginning at \c result
+//! in reverse order. When the source range uses segmented iterators,
+//! exploits segmentation by walking segments in reverse order, processing
+//! each local range without per-element segment-boundary overhead.
+//! When the output range also uses segmented iterators, walks output
+//! segments as well (dual-segmented / multi-segmented dispatch).
+//! Returns the output iterator past the last element written.
+template <class BidirIter, class OutIter>
+BOOST_CONTAINER_FORCEINLINE OutIter segmented_reverse_copy(BidirIter first, BidirIter last, OutIter result)
+{
+   typedef segmented_iterator_traits<BidirIter> traits;
+   return detail_algo::segmented_reverse_copy_dispatch
+      (first, last, result, typename traits::is_segmented_iterator(), typename iterator_traits<BidirIter>::iterator_category());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_REVERSE_COPY_HPP

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

@@ -0,0 +1,211 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_SEARCH_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_SEARCH_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/experimental/segmented_find_if.hpp>
+#include <boost/container/experimental/segmented_mismatch.hpp>
+
+namespace boost {
+namespace container {
+
+template <class FwdIt1, class Sent1, class FwdIt2, class Sent2>
+FwdIt1 segmented_search
+   (FwdIt1 first, Sent1 last, FwdIt2 s_first, Sent2 s_last);
+
+namespace detail_algo {
+
+/* ---------------------------------------------------------------------------
+   Original (non-recursive) implementation. Kept here for reference.
+   It only exploits one level of segmentation on the [first, last) haystack
+   and no segmentation on the [s_first, s_last) needle. The verification
+   step (matches_at) walks the fully composed segmented iterator one element
+   at a time, which pays the segmented-increment cost on every step.
+
+template <class FwdIt1, class Sent, class FwdIt2, class Sent2>
+bool matches_at(FwdIt1 pos, Sent last, FwdIt2 s_first, Sent2 s_last)
+{
+   for(; s_first != s_last; ++s_first, ++pos)
+      if(pos == last || !(*pos == *s_first))
+         return false;
+   return true;
+}
+
+// Non-recursive: match verification (matches_at) must span across segment
+// boundaries using the full segmented iterator.
+template <class SegIter, class FwdIt2, class Sent2>
+SegIter segmented_search_dispatch
+   (SegIter first, SegIter last, FwdIt2 s_first, Sent2 s_last, segmented_iterator_tag)
+{
+   if(s_first == s_last) return first;
+
+   typedef segmented_iterator_traits<SegIter> traits;
+   typedef typename traits::local_iterator    local_iterator;
+   typedef typename traits::segment_iterator  segment_iterator;
+
+   segment_iterator scur  = traits::segment(first);
+   segment_iterator slast = traits::segment(last);
+   local_iterator   lcur  = traits::local(first);
+
+   if(scur == slast) {
+      local_iterator lend = traits::local(last);
+      for(; lcur != lend; ++lcur) {
+         if(*lcur == *s_first) {
+            SegIter pos = traits::compose(scur, lcur);
+            if(matches_at(pos, last, s_first, s_last))
+               return pos;
+         }
+      }
+   }
+   else {
+      {
+         local_iterator lend = traits::end(scur);
+         for(; lcur != lend; ++lcur) {
+            if(*lcur == *s_first) {
+               SegIter pos = traits::compose(scur, lcur);
+               if(matches_at(pos, last, s_first, s_last))
+                  return pos;
+            }
+         }
+      }
+      for(++scur; scur != slast; ++scur) {
+         local_iterator lb = traits::begin(scur);
+         local_iterator le = traits::end(scur);
+         for(lcur = lb; lcur != le; ++lcur) {
+            if(*lcur == *s_first) {
+               SegIter pos = traits::compose(scur, lcur);
+               if(matches_at(pos, last, s_first, s_last))
+                  return pos;
+            }
+         }
+      }
+      {
+         local_iterator lb = traits::begin(scur);
+         local_iterator ll = traits::local(last);
+         for(lcur = lb; lcur != ll; ++lcur) {
+            if(*lcur == *s_first) {
+               SegIter pos = traits::compose(scur, lcur);
+               if(matches_at(pos, last, s_first, s_last))
+                  return pos;
+            }
+         }
+      }
+   }
+   return last;
+}
+--------------------------------------------------------------------------- */
+
+//////////////////////////////////////////////////////////////////////////////
+// Recursive segmented dispatch: find-then-verify.
+//
+// 1. segmented_find_if locates a candidate c where *c == *s_first, walking
+//    the source recursively (exploits every level of segmentation and uses
+//    the unrolled RA fast path at the leaves).
+// 2. segmented_mismatch_bounded_dispatch verifies the match starting at
+//    (c, s_first), bounded on both sides, recursive on both sides.
+//
+// The equal_to_deref predicate keeps the search proxy-safe: *s_first is
+// re-evaluated on every comparison, so a prvalue proxy never outlives the
+// call that produced it.
+//////////////////////////////////////////////////////////////////////////////
+template <class SegIter, class FwdIt2, class Sent2>
+SegIter segmented_search_dispatch
+   (SegIter first, SegIter last, FwdIt2 s_first, Sent2 s_last, segmented_iterator_tag)
+{
+   if (s_first == s_last)
+      return first;
+
+   typedef typename iterator_traits<SegIter>::iterator_category cat_t;
+
+   equal_to_deref<FwdIt2> eq(s_first);
+
+   while (first != last) {
+      //Search for the first element of the needle. This exploits segmentation
+      first = boost::container::segmented_find_if(first, last, eq);
+      if (first == last)   // no match for the first needle element -> no match at all
+         return last;
+
+      //Verify the rest of the needle, bounded on both sides. This exploits segmentation
+      segduo<SegIter, FwdIt2> r = (segmented_mismatch_bounded_dispatch)
+         (first, last, s_first, s_last, mismatch_equal(), segmented_iterator_tag(), cat_t());
+
+      if (r.second == s_last)
+         return first;          // full needle consumed -> match
+      if (r.first == last)
+         return last;           // source exhausted before needle
+      ++first;
+   }
+   return last;
+}
+
+template <class FwdIt1, class Sent1, class FwdIt2, class Sent2, class Tag>
+typename algo_enable_if_c<
+   !Tag::value || is_sentinel<Sent1, FwdIt1>::value, FwdIt1>::type
+segmented_search_dispatch
+   (FwdIt1 first, Sent1 last, FwdIt2 s_first, Sent2 s_last, Tag)
+{
+   if (s_first == s_last)
+      return first;
+
+   equal_to_deref<FwdIt2> eq(s_first);
+
+   while (first != last) {
+      first = boost::container::segmented_find_if(first, last, eq);
+      if (first == last)
+         return last;
+
+      FwdIt1 it = first;
+      FwdIt2 s_it = s_first;
+      for(;;) {
+         ++it;
+         ++s_it;
+         if(s_it == s_last)
+            return first;
+         if(it == last)
+            return last;
+         if(!(*it == *s_it))
+            break;
+      }
+      ++first;
+   }
+   return last;
+}
+
+} // namespace detail_algo
+
+//! Finds the first occurrence of the subsequence [s_first, s_last) in [first, last).
+//! Returns an iterator to the beginning of the found subsequence, or \c last if not found.
+//! Exploits segmentation recursively on both ranges.
+template <class FwdIt1, class Sent1, class FwdIt2, class Sent2>
+BOOST_CONTAINER_FORCEINLINE
+FwdIt1 segmented_search(FwdIt1 first, Sent1 last, FwdIt2 s_first, Sent2 s_last)
+{
+   typedef segmented_iterator_traits<FwdIt1> traits;
+   return detail_algo::segmented_search_dispatch
+      (first, last, s_first, s_last, typename traits::is_segmented_iterator());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_SEARCH_HPP