passenger 6.2.1 → 6.2.2

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

@@ -0,0 +1,110 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_FIND_IF_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_IF_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>
+
+namespace boost {
+namespace container {
+
+template <class InpIter, class Sent, class Pred>
+InpIter segmented_find_if(InpIter first, Sent last, Pred pred);
+
+namespace detail_algo {
+
+template <class InpIter, class Sent, class Pred, class Tag, class Cat>
+BOOST_CONTAINER_FORCEINLINE
+typename algo_enable_if_c<
+   !Tag::value || is_sentinel<Sent, InpIter>::value, InpIter>::type
+segmented_find_if_dispatch(InpIter first, Sent last, Pred pred, Tag, Cat)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; first != last; ++first)
+      if(pred(*first))
+         break;
+   return first;
+}
+
+template <class SegIter, class Pred, class Cat>
+SegIter segmented_find_if_dispatch
+   (SegIter first, SegIter last, Pred pred, 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);
+   const segment_iterator slast  = traits::segment(last);
+
+   if(sfirst == slast) {
+      const local_iterator ll = traits::local(last);
+      const local_iterator r = (segmented_find_if_dispatch)(traits::local(first), ll, pred, is_local_seg_t(), local_cat_t());
+      if (r != ll)
+         return traits::compose(sfirst, r);
+   }
+   else {
+      //First segment
+      {
+         const local_iterator le = traits::end(sfirst);
+         const local_iterator r = (segmented_find_if_dispatch)(traits::local(first), le, pred, is_local_seg_t(), local_cat_t());
+         if (r != le)
+            return traits::compose(sfirst, r);
+      }
+      //Middle segments
+      for (++sfirst; sfirst != slast; ++sfirst) {
+         const local_iterator le = traits::end(sfirst);
+         const local_iterator r = (segmented_find_if_dispatch)(traits::begin(sfirst), le, pred, is_local_seg_t(), local_cat_t());
+         if (r != le)
+            return traits::compose(sfirst, r);
+      }
+      //Last segment
+      {
+         const local_iterator ll = traits::local(last);
+         const local_iterator r = (segmented_find_if_dispatch)(traits::begin(slast), traits::local(last), pred, is_local_seg_t(), local_cat_t());
+         if (r != ll)
+            return traits::compose(sfirst, r);
+      }
+   }
+   return last;
+}
+
+} // namespace detail_algo
+
+//! Returns an iterator to the first element satisfying \c pred
+//! in [first, last), or \c last if not found.
+template <class InpIter, class Sent, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+InpIter segmented_find_if(InpIter first, Sent last, Pred pred)
+{
+   typedef segmented_iterator_traits<InpIter> traits;
+   return detail_algo::segmented_find_if_dispatch
+      (first, last, pred, typename traits::is_segmented_iterator(), typename iterator_traits<InpIter>::iterator_category());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_IF_HPP

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

@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_FIND_IF_NOT_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_IF_NOT_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/compare_functors.hpp>
+#include <boost/container/experimental/segmented_find_if.hpp>
+
+namespace boost {
+namespace container {
+
+//! Returns an iterator to the first element for which \c pred
+//! returns false in [first, last), or \c last if not found.
+template <class InpIter, class Sent, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+InpIter segmented_find_if_not(InpIter first, Sent last, Pred pred)
+{
+   return (segmented_find_if)(first, last, not_pred<Pred>(pred));
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_IF_NOT_HPP

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

@@ -0,0 +1,179 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_FIND_LAST_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_LAST_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>
+#include <boost/container/experimental/segmented_iterator_traits.hpp>
+
+namespace boost {
+namespace container {
+
+template <class FwdIt, class Sent, class T>
+FwdIt segmented_find_last(FwdIt first, Sent last, const T& value);
+
+namespace detail_algo {
+
+//////////////////////////////////////////////
+// Non-segmented scans
+//////////////////////////////////////////////
+
+template <class FwdIt, class Sent, class T>
+BOOST_CONTAINER_FORCEINLINE
+FwdIt find_last_scan(FwdIt first, Sent last, const T& value,
+                     non_segmented_iterator_tag, const std::forward_iterator_tag&)
+{
+   FwdIt result = last;
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for (; first != last; ++first)
+      if (*first == value)
+         result = first;
+   return result;
+}
+
+template <class BidirIt, class T>
+BOOST_CONTAINER_FORCEINLINE
+BidirIt find_last_scan(BidirIt first, BidirIt last, const T& value,
+                       non_segmented_iterator_tag, const std::bidirectional_iterator_tag&)
+{
+   BidirIt cur = last;
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   while (cur != first) {
+      --cur;
+      if (*cur == value)
+         return cur;
+   }
+   return last;
+}
+
+//////////////////////////////////////////////
+// Segmented forward scan
+//////////////////////////////////////////////
+
+template <class SegIt, class T>
+SegIt find_last_scan(SegIt first, SegIt last, const T& value,
+                     segmented_iterator_tag, const std::forward_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 typename iterator_traits<local_iterator>::iterator_category               local_cat_t;
+
+   SegIt result = last;
+   segment_iterator       sfirst = traits::segment(first);
+   const segment_iterator slast  = traits::segment(last);
+
+   if (sfirst == slast) {
+      return traits::compose
+         (sfirst, find_last_scan(traits::local(first), traits::local(last), value, is_local_seg_t(), local_cat_t()));
+   }
+   else {
+      {  // First segment
+         const local_iterator le = traits::end(sfirst);
+         const local_iterator r = find_last_scan(traits::local(first), le, value, is_local_seg_t(), local_cat_t());
+         if (r != le)
+            result = traits::compose(sfirst, r);
+      }
+         // Middle segments
+      for (++sfirst; sfirst != slast; ++sfirst) {
+         const local_iterator le = traits::end(sfirst);
+         const local_iterator r = find_last_scan(traits::begin(sfirst), le, value, is_local_seg_t(), local_cat_t());
+         if (r != le)
+            result = traits::compose(sfirst, r);
+      }
+      // Last segment
+      return traits::compose
+         (sfirst, find_last_scan(traits::begin(slast), traits::local(last), value, is_local_seg_t(), local_cat_t()));
+   }
+}
+
+//////////////////////////////////////////////
+// Segmented bidirectional scan
+//////////////////////////////////////////////
+
+template <class SegIt, class T>
+SegIt find_last_scan(SegIt first, SegIt last, const T& value, segmented_iterator_tag, const std::bidirectional_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 typename iterator_traits<local_iterator>::iterator_category local_cat_t;
+
+   segment_iterator const sfirst = traits::segment(first);
+   segment_iterator       slast  = traits::segment(last);
+   const local_iterator ll = traits::local(last);
+
+   if (sfirst == slast) {
+      return traits::compose
+         (sfirst, find_last_scan(traits::local(first), ll, value, is_local_seg_t(), local_cat_t()));
+   }
+
+   {  // Last segment (partial): [begin(slast), local(last))
+      local_iterator r = find_last_scan(traits::begin(slast), ll, value, is_local_seg_t(), local_cat_t());
+      if (r != ll)
+         return traits::compose(slast, r);
+   }
+
+   // Middle segments in reverse
+   for (--slast; slast != sfirst; --slast) {
+      const local_iterator le = traits::end(slast);
+      const local_iterator r = find_last_scan(traits::begin(slast), le, value, is_local_seg_t(), local_cat_t());
+      if (r != le)
+         return traits::compose(slast, r);
+   }
+
+   {  // First segment (partial): [local(first), end(sfirst))
+      const local_iterator le = traits::end(sfirst);
+      const local_iterator r  = find_last_scan(traits::local(first), le, value, is_local_seg_t(), local_cat_t());
+      if (r != le)
+         return traits::compose(sfirst, r);
+   }
+
+   return last;
+}
+
+//////////////////////////////////////////////
+// Sentinel / generic fallback
+//////////////////////////////////////////////
+
+} // namespace detail_algo
+
+//! Returns an iterator to the last element equal to \c value
+//! in [first, last), or \c last if not found.
+//! For bidirectional iterators, scans backward for early exit.
+//! For forward iterators, scans the entire range and remembers
+//! the last match.
+template <class FwdIt, class Sent, class T>
+BOOST_CONTAINER_FORCEINLINE
+FwdIt segmented_find_last(FwdIt first, Sent last, const T& value)
+{
+   typedef detail_algo::sent_filter<FwdIt, Sent> sf;
+   return detail_algo::find_last_scan
+      ( first, last, value, typename sf::seg_t(), typename sf::cat_t());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_LAST_HPP

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

@@ -0,0 +1,179 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_FIND_LAST_IF_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_LAST_IF_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>
+#include <boost/container/experimental/segmented_iterator_traits.hpp>
+
+namespace boost {
+namespace container {
+
+template <class FwdIt, class Sent, class Pred>
+FwdIt segmented_find_last_if(FwdIt first, Sent last, Pred pred);
+
+namespace detail_algo {
+
+//////////////////////////////////////////////
+// Non-segmented scans
+//////////////////////////////////////////////
+
+template <class FwdIt, class Sent, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+FwdIt find_last_if_scan(FwdIt first, Sent last, Pred pred,
+                        non_segmented_iterator_tag, const std::forward_iterator_tag&)
+{
+   FwdIt result = last;
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for (; first != last; ++first)
+      if (pred(*first))
+         result = first;
+   return result;
+}
+
+template <class BidirIt, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+BidirIt find_last_if_scan(BidirIt first, BidirIt last, Pred pred,
+                          non_segmented_iterator_tag, const std::bidirectional_iterator_tag&)
+{
+   BidirIt cur = last;
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   while (cur != first) {
+      --cur;
+      if (pred(*cur))
+         return cur;
+   }
+   return last;
+}
+
+//////////////////////////////////////////////
+// Segmented forward scan
+//////////////////////////////////////////////
+
+template <class SegIt, class Pred>
+SegIt find_last_if_scan(SegIt first, SegIt last, Pred pred,
+                        segmented_iterator_tag, const std::forward_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 typename iterator_traits<local_iterator>::iterator_category               local_cat_t;
+
+   SegIt result = last;
+   segment_iterator       sfirst = traits::segment(first);
+   const segment_iterator slast  = traits::segment(last);
+
+   if (sfirst == slast) {
+      return traits::compose
+         (sfirst, find_last_if_scan(traits::local(first), traits::local(last), pred, is_local_seg_t(), local_cat_t()));
+   }
+   else {
+      {  // First segment
+         const local_iterator le = traits::end(sfirst);
+         const local_iterator r = find_last_if_scan(traits::local(first), le, pred, is_local_seg_t(), local_cat_t());
+         if (r != le)
+            result = traits::compose(sfirst, r);
+      }
+         // Middle segments
+      for (++sfirst; sfirst != slast; ++sfirst) {
+         const local_iterator le = traits::end(sfirst);
+         const local_iterator r = find_last_if_scan(traits::begin(sfirst), le, pred, is_local_seg_t(), local_cat_t());
+         if (r != le)
+            result = traits::compose(sfirst, r);
+      }
+      // Last segment
+      return traits::compose
+         (sfirst, find_last_if_scan(traits::begin(slast), traits::local(last), pred, is_local_seg_t(), local_cat_t()));
+   }
+}
+
+//////////////////////////////////////////////
+// Segmented bidirectional scan
+//////////////////////////////////////////////
+
+template <class SegIt, class Pred>
+SegIt find_last_if_scan(SegIt first, SegIt last, Pred pred, segmented_iterator_tag, const std::bidirectional_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 typename iterator_traits<local_iterator>::iterator_category local_cat_t;
+
+   segment_iterator const sfirst = traits::segment(first);
+   segment_iterator       slast  = traits::segment(last);
+   const local_iterator ll = traits::local(last);
+
+   if (sfirst == slast) {
+      return traits::compose
+         (sfirst, find_last_if_scan(traits::local(first), ll, pred, is_local_seg_t(), local_cat_t()));
+   }
+
+   {  // Last segment (partial): [begin(slast), local(last))
+      local_iterator r = find_last_if_scan(traits::begin(slast), ll, pred, is_local_seg_t(), local_cat_t());
+      if (r != ll)
+         return traits::compose(slast, r);
+   }
+
+   // Middle segments in reverse
+   for (--slast; slast != sfirst; --slast) {
+      const local_iterator le = traits::end(slast);
+      const local_iterator r = find_last_if_scan(traits::begin(slast), le, pred, is_local_seg_t(), local_cat_t());
+      if (r != le)
+         return traits::compose(slast, r);
+   }
+
+   {  // First segment (partial): [local(first), end(sfirst))
+      const local_iterator le = traits::end(sfirst);
+      const local_iterator r  = find_last_if_scan(traits::local(first), le, pred, is_local_seg_t(), local_cat_t());
+      if (r != le)
+         return traits::compose(sfirst, r);
+   }
+
+   return last;
+}
+
+//////////////////////////////////////////////
+// Sentinel / generic fallback
+//////////////////////////////////////////////
+
+} // namespace detail_algo
+
+//! Returns an iterator to the last element satisfying \c pred
+//! in [first, last), or \c last if not found.
+//! For bidirectional iterators, scans backward for early exit.
+//! For forward iterators, scans the entire range and remembers
+//! the last match.
+template <class FwdIt, class Sent, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+FwdIt segmented_find_last_if(FwdIt first, Sent last, Pred pred)
+{
+   typedef detail_algo::sent_filter<FwdIt, Sent> sf;
+   return detail_algo::find_last_if_scan
+      ( first, last, pred, typename sf::seg_t(), typename sf::cat_t());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_LAST_IF_HPP

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

@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_FIND_LAST_IF_NOT_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_LAST_IF_NOT_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/compare_functors.hpp>
+#include <boost/container/experimental/segmented_find_last_if.hpp>
+
+namespace boost {
+namespace container {
+
+//! Returns an iterator to the last element for which \c pred
+//! returns false in [first, last), or \c last if not found.
+template <class FwdIt, class Sent, class Pred>
+BOOST_CONTAINER_FORCEINLINE
+FwdIt segmented_find_last_if_not(FwdIt first, Sent last, Pred pred)
+{
+   return (segmented_find_last_if)(first, last, not_pred<Pred>(pred));
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FIND_LAST_IF_NOT_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/experimental/segmented_for_each.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_FOR_EACH_HPP
+#define BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FOR_EACH_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 InpIter, class Sent, class F>
+F segmented_for_each(InpIter first, Sent last, F f);
+
+namespace detail_algo {
+
+template <class InpIter, class Sent, class F, class Tag, class Cat>
+typename algo_enable_if_c<
+   !Tag::value || is_sentinel<Sent, InpIter>::value, F>::type
+BOOST_CONTAINER_FORCEINLINE
+segmented_for_each_dispatch
+   (InpIter first, Sent last, F f, Tag, Cat)
+{
+   BOOST_CONTAINER_SEGMENTED_UNROLL(4)
+   for(; first != last; ++first)
+      f(*first);
+   return f;
+}
+
+template <class SegIter, class F, class Cat>
+F segmented_for_each_dispatch
+   (SegIter first, SegIter last, F f, 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) {
+      return (segmented_for_each_dispatch)(traits::local(first), traits::local(last), boost::move(f), is_local_seg_t(), local_cat_t());
+   }
+   else {
+      f = (segmented_for_each_dispatch)(traits::local(first), traits::end(sfirst), boost::move(f), is_local_seg_t(), local_cat_t());
+      for(++sfirst; sfirst != slast; ++sfirst)
+         f = (segmented_for_each_dispatch)(traits::begin(sfirst), traits::end(sfirst), boost::move(f), is_local_seg_t(), local_cat_t());
+      return (segmented_for_each_dispatch)(traits::begin(sfirst), traits::local(last), boost::move(f), is_local_seg_t(), local_cat_t());
+   }
+}
+
+} // namespace detail_algo
+
+//! Applies \c f to every element in [first, last).
+//! Returns the (possibly modified) function object.
+//! When \c Iter is a segmented iterator, exploits segmentation
+//! to reduce per-element overhead.
+template <class InpIter, class Sent, class F>
+BOOST_CONTAINER_FORCEINLINE
+F segmented_for_each(InpIter first, Sent last, F f)
+{
+   typedef segmented_iterator_traits<InpIter> traits;
+   return detail_algo::segmented_for_each_dispatch
+      (first, last, boost::move(f), typename traits::is_segmented_iterator(), typename iterator_traits<InpIter>::iterator_category());
+}
+
+} // namespace container
+} // namespace boost
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_CONTAINER_EXPERIMENTAL_SEGMENTED_FOR_EACH_HPP