This commit was manufactured by cvs2svn to create branch

'thread_rewrite'.

[SVN r30953]

include/boost/algorithm/minmax.hpp

@@ -0,0 +1,47 @@
+//  (C) Copyright Herve Bronnimann 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   1 July 2004
+      Split the code into two headers to lessen dependence on
+      Boost.tuple. (Herve)
+   26 June 2004
+      Added the code for the boost minmax library. (Herve)
+*/
+
+#ifndef BOOST_ALGORITHM_MINMAX_HPP
+#define BOOST_ALGORITHM_MINMAX_HPP
+
+/* PROPOSED STANDARD EXTENSIONS:
+ *
+ * minmax(a, b)
+ * Effect: (b<a) ? std::make_pair(b,a) : std::make_pair(a,b);
+ *
+ * minmax(a, b, comp)
+ * Effect: comp(b,a) ? std::make_pair(b,a) : std::make_pair(a,b);
+ *
+ */
+
+#include <boost/tuple/tuple.hpp> // for using pairs with boost::cref
+#include <boost/ref.hpp>
+
+namespace boost {
+
+  template <typename T>
+  tuple< T const&, T const& >
+  minmax(T const& a, T const& b) {
+    return (b<a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b));
+  }
+
+  template <typename T, class BinaryPredicate>
+  tuple< T const&, T const& >
+  minmax(T const& a, T const& b, BinaryPredicate comp) {
+    return comp(b,a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b));
+  }
+
+} // namespace boost
+
+#endif // BOOST_ALGORITHM_MINMAX_HPP

include/boost/algorithm/minmax_element.hpp

@@ -0,0 +1,551 @@
+//  (C) Copyright Herve Bronnimann 2004.
+//  Use, modification and distribution are subject to 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)
+
+/*
+ Revision history:
+   1 July 2004
+      Split the code into two headers to lessen dependence on
+      Boost.tuple. (Herve)
+   26 June 2004
+      Added the code for the boost minmax library. (Herve)
+*/
+
+#ifndef BOOST_ALGORITHM_MINMAX_ELEMENT_HPP
+#define BOOST_ALGORITHM_MINMAX_ELEMENT_HPP
+
+/* PROPOSED STANDARD EXTENSIONS:
+ *
+ * minmax_element(first, last)
+ * Effect: std::make_pair( std::min_element(first, last),
+ *                         std::max_element(first, last) );
+ *
+ * minmax_element(first, last, comp)
+ * Effect: std::make_pair( std::min_element(first, last, comp),
+ *                         std::max_element(first, last, comp) );
+ */
+
+#include <utility> // for std::pair and std::make_pair
+
+namespace boost {
+
+  namespace detail {  // for obtaining a uniform version of minmax_element
+    // that compiles with VC++ 6.0 -- avoid the iterator_traits by
+    // having comparison object over iterator, not over dereferenced value
+
+    template <typename Iterator>
+    struct less_over_iter {
+      bool operator()(Iterator const& it1,
+                      Iterator const& it2) const { return *it1 < *it2; }
+    };
+
+    template <typename Iterator, class BinaryPredicate>
+    struct binary_pred_over_iter {
+      explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p ) {}
+      bool operator()(Iterator const& it1,
+                      Iterator const& it2) const { return m_p(*it1, *it2); }
+    private:
+      BinaryPredicate m_p;
+    };
+
+    // common base for the two minmax_element overloads
+
+    template <typename ForwardIter, class Compare >
+    std::pair<ForwardIter,ForwardIter>
+    basic_minmax_element(ForwardIter first, ForwardIter last, Compare comp)
+    {
+      if (first == last)
+        return std::make_pair(last,last);
+
+      ForwardIter min_result = first;
+      ForwardIter max_result = first;
+
+      // if only one element
+      ForwardIter second = first; ++second;
+      if (second == last)
+        return std::make_pair(min_result, max_result);
+
+      // treat first pair separately (only one comparison for first two elements)
+      ForwardIter potential_min_result = last;
+      if (comp(first, second))
+        max_result = second;
+      else {
+        min_result = second;
+        potential_min_result = first;
+      }
+
+      // then each element by pairs, with at most 3 comparisons per pair
+      first = ++second; if (first != last) ++second;
+      while (second != last) {
+        if (comp(first, second)) {
+          if (comp(first, min_result)) {
+            min_result = first;
+            potential_min_result = last;
+          }
+          if (comp(max_result, second))
+            max_result = second;
+        } else {
+          if (comp(second, min_result)) {
+            min_result = second;
+            potential_min_result = first;
+          }
+          if (comp(max_result, first))
+            max_result = first;
+        }
+        first = ++second;
+        if (first != last) ++second;
+      }
+
+      // if odd number of elements, treat last element
+      if (first != last) { // odd number of elements
+        if (comp(first, min_result))
+          min_result = first, potential_min_result = last;
+        else if (comp(max_result, first))
+          max_result = first;
+      }
+
+      // resolve min_result being incorrect with one extra comparison
+      // (in which case potential_min_result is necessarily the correct result)
+      if (potential_min_result != last
+        && !comp(min_result, potential_min_result))
+        min_result = potential_min_result;
+
+      return std::make_pair(min_result,max_result);
+    }
+
+  } // namespace detail
+
+  template <typename ForwardIter>
+  std::pair<ForwardIter,ForwardIter>
+  minmax_element(ForwardIter first, ForwardIter last)
+  {
+    return detail::basic_minmax_element(first, last,
+             detail::less_over_iter<ForwardIter>() );
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  std::pair<ForwardIter,ForwardIter>
+  minmax_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+  {
+    return detail::basic_minmax_element(first, last,
+             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+  }
+
+}
+
+/* PROPOSED BOOST EXTENSIONS
+ * In the description below, [rfirst,rlast) denotes the reversed range
+ * of [first,last). Even though the iterator type of first and last may
+ * be only a Forward Iterator, it is possible to explain the semantics
+ * by assuming that it is a Bidirectional Iterator. In the sequel,
+ * reverse(ForwardIterator&) returns the reverse_iterator adaptor.
+ * This is not how the functions would be implemented!
+ *
+ * first_min_element(first, last)
+ * Effect: std::min_element(first, last);
+ *
+ * first_min_element(first, last, comp)
+ * Effect: std::min_element(first, last, comp);
+ *
+ * last_min_element(first, last)
+ * Effect: reverse( std::min_element(reverse(last), reverse(first)) );
+ *
+ * last_min_element(first, last, comp)
+ * Effect: reverse( std::min_element(reverse(last), reverse(first), comp) );
+ *
+ * first_max_element(first, last)
+ * Effect: std::max_element(first, last);
+ *
+ * first_max_element(first, last, comp)
+ * Effect: max_element(first, last);
+ *
+ * last_max_element(first, last)
+ * Effect: reverse( std::max_element(reverse(last), reverse(first)) );
+ *
+ * last_max_element(first, last, comp)
+ * Effect: reverse( std::max_element(reverse(last), reverse(first), comp) );
+ *
+ * first_min_first_max_element(first, last)
+ * Effect: std::make_pair( first_min_element(first, last),
+ *                         first_max_element(first, last) );
+ *
+ * first_min_first_max_element(first, last, comp)
+ * Effect: std::make_pair( first_min_element(first, last, comp),
+ *                         first_max_element(first, last, comp) );
+ *
+ * first_min_last_max_element(first, last)
+ * Effect: std::make_pair( first_min_element(first, last),
+ *                         last_max_element(first, last) );
+ *
+ * first_min_last_max_element(first, last, comp)
+ * Effect: std::make_pair( first_min_element(first, last, comp),
+ *                         last_max_element(first, last, comp) );
+ *
+ * last_min_first_max_element(first, last)
+ * Effect: std::make_pair( last_min_element(first, last),
+ *                         first_max_element(first, last) );
+ *
+ * last_min_first_max_element(first, last, comp)
+ * Effect: std::make_pair( last_min_element(first, last, comp),
+ *                         first_max_element(first, last, comp) );
+ *
+ * last_min_last_max_element(first, last)
+ * Effect: std::make_pair( last_min_element(first, last),
+ *                         last_max_element(first, last) );
+ *
+ * last_min_last_max_element(first, last, comp)
+ * Effect: std::make_pair( last_min_element(first, last, comp),
+ *                         last_max_element(first, last, comp) );
+ */
+
+namespace boost {
+
+  // Min_element and max_element variants
+
+  namespace detail {  // common base for the overloads
+
+  template <typename ForwardIter, class BinaryPredicate>
+  ForwardIter
+  basic_first_min_element(ForwardIter first, ForwardIter last,
+                          BinaryPredicate comp)
+  {
+    if (first == last) return last;
+    ForwardIter min_result = first;
+    while (++first != last)
+      if (comp(first, min_result))
+        min_result = first;
+    return min_result;
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  ForwardIter
+  basic_last_min_element(ForwardIter first, ForwardIter last,
+                         BinaryPredicate comp)
+  {
+    if (first == last) return last;
+    ForwardIter min_result = first;
+    while (++first != last)
+      if (!comp(min_result, first))
+        min_result = first;
+    return min_result;
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  ForwardIter
+  basic_first_max_element(ForwardIter first, ForwardIter last,
+                          BinaryPredicate comp)
+  {
+    if (first == last) return last;
+    ForwardIter max_result = first;
+    while (++first != last)
+      if (comp(max_result, first))
+        max_result = first;
+    return max_result;
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  ForwardIter
+  basic_last_max_element(ForwardIter first, ForwardIter last,
+                         BinaryPredicate comp)
+  {
+    if (first == last) return last;
+    ForwardIter max_result = first;
+    while (++first != last)
+      if (!comp(first, max_result))
+        max_result = first;
+    return max_result;
+  }
+
+  } // namespace detail
+
+  template <typename ForwardIter>
+  ForwardIter
+  first_min_element(ForwardIter first, ForwardIter last)
+  {
+    return detail::basic_first_min_element(first, last,
+             detail::less_over_iter<ForwardIter>() );
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  ForwardIter
+  first_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+  {
+    return detail::basic_first_min_element(first, last,
+             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+  }
+
+  template <typename ForwardIter>
+  ForwardIter
+  last_min_element(ForwardIter first, ForwardIter last)
+  {
+    return detail::basic_last_min_element(first, last,
+             detail::less_over_iter<ForwardIter>() );
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  ForwardIter
+  last_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+  {
+    return detail::basic_last_min_element(first, last,
+             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+  }
+
+  template <typename ForwardIter>
+  ForwardIter
+  first_max_element(ForwardIter first, ForwardIter last)
+  {
+    return detail::basic_first_max_element(first, last,
+             detail::less_over_iter<ForwardIter>() );
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  ForwardIter
+  first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+  {
+    return detail::basic_first_max_element(first, last,
+             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+  }
+
+  template <typename ForwardIter>
+  ForwardIter
+  last_max_element(ForwardIter first, ForwardIter last)
+  {
+    return detail::basic_last_max_element(first, last,
+             detail::less_over_iter<ForwardIter>() );
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  ForwardIter
+  last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+  {
+    return detail::basic_last_max_element(first, last,
+             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+  }
+
+
+  // Minmax_element variants -- comments removed
+
+  namespace detail {
+
+  template <typename ForwardIter, class BinaryPredicate>
+  std::pair<ForwardIter,ForwardIter>
+  basic_first_min_last_max_element(ForwardIter first, ForwardIter last,
+                                   BinaryPredicate comp)
+  {
+    if (first == last)
+      return std::make_pair(last,last);
+
+    ForwardIter min_result = first;
+    ForwardIter max_result = first;
+
+    ForwardIter second = ++first;
+    if (second == last)
+      return std::make_pair(min_result, max_result);
+
+    if (comp(second, min_result))
+      min_result = second;
+    else
+      max_result = second;
+
+    first = ++second; if (first != last) ++second;
+    while (second != last) {
+      if (!comp(second, first)) {
+        if (comp(first, min_result))
+                 min_result = first;
+        if (!comp(second, max_result))
+          max_result = second;
+      } else {
+        if (comp(second, min_result))
+          min_result = second;
+        if (!comp(first, max_result))
+              max_result = first;
+      }
+      first = ++second; if (first != last) ++second;
+    }
+
+    if (first != last) {
+      if (comp(first, min_result))
+         min_result = first;
+      else if (!comp(first, max_result))
+               max_result = first;
+    }
+
+    return std::make_pair(min_result, max_result);
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  std::pair<ForwardIter,ForwardIter>
+  basic_last_min_first_max_element(ForwardIter first, ForwardIter last,
+                                   BinaryPredicate comp)
+  {
+    if (first == last) return std::make_pair(last,last);
+
+    ForwardIter min_result = first;
+    ForwardIter max_result = first;
+
+    ForwardIter second = ++first;
+    if (second == last)
+      return std::make_pair(min_result, max_result);
+
+    if (comp(max_result, second))
+      max_result = second;
+    else
+      min_result = second;
+
+    first = ++second; if (first != last) ++second;
+    while (second != last)  {
+      if (comp(first, second)) {
+        if (!comp(min_result, first))
+          min_result = first;
+        if (comp(max_result, second))
+          max_result = second;
+      } else {
+        if (!comp(min_result, second))
+          min_result = second;
+        if (comp(max_result, first))
+          max_result = first;
+      }
+      first = ++second; if (first != last) ++second;
+    }
+
+    if (first != last) {
+      if (!comp(min_result, first))
+        min_result = first;
+      else if (comp(max_result, first))
+        max_result = first;
+    }
+
+    return std::make_pair(min_result, max_result);
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  std::pair<ForwardIter,ForwardIter>
+  basic_last_min_last_max_element(ForwardIter first, ForwardIter last,
+                                  BinaryPredicate comp)
+  {
+    if (first == last) return std::make_pair(last,last);
+
+    ForwardIter min_result = first;
+    ForwardIter max_result = first;
+
+    ForwardIter second = first; ++second;
+    if (second == last)
+      return std::make_pair(min_result,max_result);
+
+    ForwardIter potential_max_result = last;
+    if (comp(first, second))
+      max_result = second;
+    else {
+      min_result = second;
+      potential_max_result = second;
+    }
+
+    first = ++second; if (first != last) ++second;
+    while (second != last) {
+      if (comp(first, second)) {
+        if (!comp(min_result, first))
+          min_result = first;
+        if (!comp(second, max_result)) {
+          max_result = second;
+          potential_max_result = last;
+        }
+      } else {
+        if (!comp(min_result, second))
+          min_result = second;
+        if (!comp(first, max_result)) {
+          max_result = first;
+          potential_max_result = second;
+        }
+      }
+      first = ++second;
+      if (first != last) ++second;
+    }
+
+    if (first != last) {
+      if (!comp(min_result, first))
+        min_result = first;
+      if (!comp(first, max_result)) {
+        max_result = first;
+               potential_max_result = last;
+      }
+    }
+
+    if (potential_max_result != last
+        && !comp(potential_max_result, max_result))
+      max_result = potential_max_result;
+
+    return std::make_pair(min_result,max_result);
+  }
+
+  } // namespace detail
+
+  template <typename ForwardIter>
+  inline std::pair<ForwardIter,ForwardIter>
+  first_min_first_max_element(ForwardIter first, ForwardIter last)
+  {
+    return minmax_element(first, last);
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  inline std::pair<ForwardIter,ForwardIter>
+  first_min_first_max_element(ForwardIter first, ForwardIter last,
+                              BinaryPredicate comp)
+  {
+    return minmax_element(first, last, comp);
+  }
+
+  template <typename ForwardIter>
+  std::pair<ForwardIter,ForwardIter>
+  first_min_last_max_element(ForwardIter first, ForwardIter last)
+  {
+    return detail::basic_first_min_last_max_element(first, last,
+             detail::less_over_iter<ForwardIter>() );
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  inline std::pair<ForwardIter,ForwardIter>
+  first_min_last_max_element(ForwardIter first, ForwardIter last,
+                              BinaryPredicate comp)
+  {
+    return detail::basic_first_min_last_max_element(first, last,
+             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+  }
+
+  template <typename ForwardIter>
+  std::pair<ForwardIter,ForwardIter>
+  last_min_first_max_element(ForwardIter first, ForwardIter last)
+  {
+    return detail::basic_last_min_first_max_element(first, last,
+             detail::less_over_iter<ForwardIter>() );
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  inline std::pair<ForwardIter,ForwardIter>
+  last_min_first_max_element(ForwardIter first, ForwardIter last,
+                              BinaryPredicate comp)
+  {
+    return detail::basic_last_min_first_max_element(first, last,
+             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+  }
+
+  template <typename ForwardIter>
+  std::pair<ForwardIter,ForwardIter>
+  last_min_last_max_element(ForwardIter first, ForwardIter last)
+  {
+    return detail::basic_last_min_last_max_element(first, last,
+             detail::less_over_iter<ForwardIter>() );
+  }
+
+  template <typename ForwardIter, class BinaryPredicate>
+  inline std::pair<ForwardIter,ForwardIter>
+  last_min_last_max_element(ForwardIter first, ForwardIter last,
+                              BinaryPredicate comp)
+  {
+    return detail::basic_last_min_last_max_element(first, last,
+             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+  }
+
+} // namespace boost
+
+#endif // BOOST_ALGORITHM_MINMAX_ELEMENT_HPP

include/boost/algorithm/string.hpp

@@ -1,9 +1,9 @@
 //  Boost string_algo library string_algo.hpp header file  ---------------------------//
 
-//  (C) Copyright Pavol Droba 2002-2003. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+//  Copyright Pavol Droba 2002-2004. Use, modification and
+//  distribution is subject to 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 for updates, documentation, and revision history.
 
@@ -15,7 +15,6 @@
 */
 
 #include <boost/algorithm/string/std_containers_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/algorithm/string/predicate.hpp>

include/boost/algorithm/string/case_conv.hpp

@@ -14,7 +14,11 @@
 #include <algorithm>
 #include <locale>
 #include <boost/iterator/transform_iterator.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
 #include <boost/algorithm/string/detail/case_conv.hpp>
 
 /*! \file
@@ -31,36 +35,37 @@ namespace boost {
         //! Convert to lower case
         /*!
             Each element of the input sequence is converted to lower
-            case. The result is copied to the given output iterator.
+            case. The result is a copy of the input converted to lower case.
+            It is returned as a sequence or copied to the output iterator.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input collection
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
             \param Loc A locale used for conversion
-            \return An output iterator pointing just after last inserted character
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
+                
         */
-        template<typename OutputIteratorT, typename CollectionT>
+        template<typename OutputIteratorT, typename RangeT>
         inline OutputIteratorT 
         to_lower_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const std::locale& Loc=std::locale())
         {
             return std::transform( 
                 begin(Input), 
                 end(Input), 
                 Output,
-                detail::to_lowerF<
-                    typename value_type_of<CollectionT>::type >(Loc));
+                ::boost::algorithm::detail::to_lowerF<
+                    typename range_value<RangeT>::type >(Loc));
         }
 
         //! Convert to lower case
         /*!
-            Each element of the input sequence is converted to lower
-            case. The result is a copy of the input converted to lower case.
-
-            \param Input An input sequence
-            \param Loc a locale used for conversion
-            \return A copy of the input converted to lower case
+            \overload
         */
         template<typename SequenceT>
         inline SequenceT to_lower_copy( 
@@ -70,12 +75,12 @@ namespace boost {
             return SequenceT(
                 make_transform_iterator(
                     begin(Input),
-                    detail::to_lowerF<
-                        typename value_type_of<SequenceT>::type >(Loc)),
+                    ::boost::algorithm::detail::to_lowerF<
+                        typename range_value<SequenceT>::type >(Loc)),
                 make_transform_iterator(
                     end(Input), 
-                    detail::to_lowerF<
-                        typename value_type_of<SequenceT>::type >(Loc)));
+                    ::boost::algorithm::detail::to_lowerF<
+                        typename range_value<SequenceT>::type >(Loc)));
         }
 
         //! Convert to lower case
@@ -83,20 +88,20 @@ namespace boost {
             Each element of the input sequence is converted to lower
             case. The input sequence is modified in-place.
 
-            \param Input A collection
+            \param Input A range
             \param Loc a locale used for conversion
         */
-        template<typename MutableCollectionT>
+        template<typename WritableRangeT>
         inline void to_lower( 
-            MutableCollectionT& Input, 
+            WritableRangeT& Input, 
             const std::locale& Loc=std::locale())
         {
             std::transform( 
                 begin(Input), 
                 end(Input), 
                 begin(Input), 
-                detail::to_lowerF<
-                    typename value_type_of<MutableCollectionT>::type >(Loc));
+                ::boost::algorithm::detail::to_lowerF<
+                    typename range_value<WritableRangeT>::type >(Loc));
         }
         
 //  to_upper  -----------------------------------------------//
@@ -104,36 +109,36 @@ namespace boost {
         //! Convert to upper case
         /*!
             Each element of the input sequence is converted to upper
-            case. The result is copied to the given output iterator.
+            case. The result is a copy of the input converted to upper case.
+            It is returned as a sequence or copied to the output iterator
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input collection
-            \param Loc a locale used for conversion
-            \return An output iterator pointing just after last inserted character
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
+            \param Loc A locale used for conversion
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT>
+        template<typename OutputIteratorT, typename RangeT>
         inline OutputIteratorT 
         to_upper_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const std::locale& Loc=std::locale())
         {
             return std::transform( 
                 begin(Input), 
                 end(Input), 
                 Output,
-                detail::to_upperF<
-                    typename value_type_of<CollectionT>::type >(Loc));
+                ::boost::algorithm::detail::to_upperF<
+                    typename range_value<RangeT>::type >(Loc));
         }
 
         //! Convert to upper case
         /*!
-            Each element of the input sequence is converted to upper
-            case. The result is a copy if the input converted to upper case.
-
-            \param Input An input sequence
-            \param Loc a locale used for conversion
-            \return A copy of the input converted to upper case
+            \overload
         */
         template<typename SequenceT>
         inline SequenceT to_upper_copy( 
@@ -143,12 +148,12 @@ namespace boost {
             return SequenceT(
                 make_transform_iterator(
                     begin(Input),
-                    detail::to_upperF<
-                        typename value_type_of<SequenceT>::type >(Loc)),
+                    ::boost::algorithm::detail::to_upperF<
+                        typename range_value<SequenceT>::type >(Loc)),
                 make_transform_iterator(
                     end(Input), 
-                    detail::to_upperF<
-                        typename value_type_of<SequenceT>::type >(Loc)));
+                    ::boost::algorithm::detail::to_upperF<
+                        typename range_value<SequenceT>::type >(Loc)));
 
         }
 
@@ -157,20 +162,20 @@ namespace boost {
             Each element of the input sequence is converted to upper
             case. The input sequence is modified in-place.
 
-            \param Input An input collection
+            \param Input An input range
             \param Loc a locale used for conversion
         */
-        template<typename MutableCollectionT>
+        template<typename WritableRangeT>
         inline void to_upper( 
-            MutableCollectionT& Input, 
+            WritableRangeT& Input, 
             const std::locale& Loc=std::locale())
         {
             std::transform( 
                 begin(Input), 
                 end(Input), 
                 begin(Input), 
-                detail::to_upperF<
-                    typename value_type_of<MutableCollectionT>::type >(Loc));
+                ::boost::algorithm::detail::to_upperF<
+                    typename range_value<WritableRangeT>::type >(Loc));
         }
 
     } // namespace algorithm

include/boost/algorithm/string/classification.hpp

@@ -12,7 +12,9 @@
 
 #include <algorithm>
 #include <locale>
+#include <boost/range/value_type.hpp>
 #include <boost/algorithm/string/detail/classification.hpp>
+#include <boost/algorithm/string/predicate_facade.hpp>
 
 /*! \file
     Classification predicates are included in the library to give 
@@ -28,7 +30,7 @@ namespace boost {
 
         //! is_classified predicate
         /*!
-            Construct the \c is_classified predicate. This predicate holds, if an input is
+            Construct the \c is_classified predicate. This predicate holds if the input is
             of specified \c std::ctype category.
 
             \param Type A \c std::ctype category
@@ -43,7 +45,7 @@ namespace boost {
 
         //! is_space predicate
         /*!
-            Construct the \c is_classified predicate for \c ctype_base::space category.   
+            Construct the \c is_classified predicate for the \c ctype_base::space category.   
 
             \param Loc A locale used for classification
             \return An instance of the \c is_classified predicate
@@ -186,24 +188,24 @@ namespace boost {
 
         //! is_any_of predicate
         /*!
-            Construct the \c is_any_of predicate. The predicate holds, if an input
+            Construct the \c is_any_of predicate. The predicate holds if the input
             is included in the specified set of characters.
 
             \param Set A set of characters to be recognized
             \return An instance of the \c is_any_of predicate 
         */
-        template<typename ContainerT>
+        template<typename RangeT>
         inline detail::is_any_ofF<
-            BOOST_STRING_TYPENAME value_type_of<ContainerT>::type> 
-        is_any_of( const ContainerT& Set )
+            BOOST_STRING_TYPENAME range_value<RangeT>::type> 
+        is_any_of( const RangeT& Set )
         {
             return detail::is_any_ofF<
-                BOOST_STRING_TYPENAME value_type_of<ContainerT>::type>(Set); 
+                BOOST_STRING_TYPENAME range_value<RangeT>::type>(Set); 
         }
 
         //! is_from_range predicate
         /*!
-            Construct the \c is_from_range predicate. The predicate holds, if an input
+            Construct the \c is_from_range predicate. The predicate holds if the input
             is included in the specified range. (i.e. From <= Ch <= To )
 
             \param From The start of the range
@@ -215,6 +217,74 @@ namespace boost {
         {
             return detail::is_from_rangeF<CharT>(From,To); 
         }
+        
+        // predicate combinators ---------------------------------------------------//
+
+        //! predicate 'and' composition predicate
+        /*!
+            Construct the \c class_and predicate. This predicate can be used
+            to logically combine two classification predicates. \c class_and holds,
+            if both predicates return true.
+
+            \param Pred1 The first predicate
+            \param Pred2 The second predicate
+            \return An instance of the \c class_and predicate     
+        */
+        template<typename Pred1T, typename Pred2T>
+        inline detail::pred_andF<Pred1T, Pred2T>
+        operator&&( 
+            const predicate_facade<Pred1T>& Pred1, 
+            const predicate_facade<Pred2T>& Pred2 )
+        {    
+            // Doing the static_cast with the pointer instead of the reference
+            // is a workaround for some compilers which have problems with
+            // static_cast's of template references, i.e. CW8. /grafik/
+            return detail::pred_andF<Pred1T,Pred2T>(
+                *static_cast<const Pred1T*>(&Pred1), 
+                *static_cast<const Pred2T*>(&Pred2) );
+        }
+
+        //! predicate 'or' composition predicate
+        /*!
+            Construct the \c class_or predicate. This predicate can be used
+            to logically combine two classification predicates. \c class_or holds,
+            if one of the predicates return true.
+
+            \param Pred1 The first predicate
+            \param Pred2 The second predicate
+            \return An instance of the \c class_or predicate     
+        */
+        template<typename Pred1T, typename Pred2T>
+        inline detail::pred_orF<Pred1T, Pred2T>
+        operator||( 
+            const predicate_facade<Pred1T>& Pred1, 
+            const predicate_facade<Pred2T>& Pred2 )
+        {    
+            // Doing the static_cast with the pointer instead of the reference
+            // is a workaround for some compilers which have problems with
+            // static_cast's of template references, i.e. CW8. /grafik/
+            return detail::pred_orF<Pred1T,Pred2T>(
+                *static_cast<const Pred1T*>(&Pred1), 
+                *static_cast<const Pred2T*>(&Pred2));
+        }
+
+        //! predicate negation operator
+        /*!
+            Construct the \c class_not predicate. This predicate represents a negation. 
+            \c class_or holds if of the predicates return false.
+
+            \param Pred The predicate to be negated
+            \return An instance of the \c class_not predicate     
+        */
+        template<typename PredT>
+        inline detail::pred_notF<PredT>
+        operator!( const predicate_facade<PredT>& Pred )
+        {
+            // Doing the static_cast with the pointer instead of the reference
+            // is a workaround for some compilers which have problems with
+            // static_cast's of template references, i.e. CW8. /grafik/
+            return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred)); 
+        }
 
     } // namespace algorithm
 
@@ -236,69 +306,4 @@ namespace boost {
 
 } // namespace boost
 
-
-// predicate combinators ---------------------------------------------------//
-/*
- *    These operators must be declared in the global namespace, otherwise 
- *  they are not resolved correctly. There will not a problem with a name-clash,
- *  since they are define only for internal types
- */ 
-
-//! predicate 'and' composition predicate
-/*!
-    Construct the \c class_and predicate. This predicate can be used
-    to logically combine two classification predicates. \c class_and holds,
-    if both predicates return true.
-
-    \param Pred1 The first predicate
-    \param Pred2 The second predicate
-    \return An instance of the \c class_and predicate     
-*/
-template<typename Pred1T, typename Pred2T>
-inline boost::algorithm::detail::pred_andF<Pred1T, Pred2T>
-operator&&( 
-    const boost::algorithm::detail::predicate_facade<Pred1T>& Pred1, 
-    const boost::algorithm::detail::predicate_facade<Pred2T>& Pred2 )
-{    
-    return boost::algorithm::detail::pred_andF<Pred1T,Pred2T>(
-        static_cast<const Pred1T&>(Pred1), 
-        static_cast<const Pred2T&>(Pred2) );
-}
-
-//! predicate 'or' composition predicate
-/*!
-    Construct the \c class_or predicate. This predicate can be used
-    to logically combine two classification predicates. \c class_or holds,
-    if one of the predicates return true.
-
-    \param Pred1 The first predicate
-    \param Pred2 The second predicate
-    \return An instance of the \c class_or predicate     
-*/
-template<typename Pred1T, typename Pred2T>
-inline boost::algorithm::detail::pred_orF<Pred1T, Pred2T>
-operator||( 
-    const boost::algorithm::detail::predicate_facade<Pred1T>& Pred1, 
-    const boost::algorithm::detail::predicate_facade<Pred2T>& Pred2 )
-{    
-    return boost::algorithm::detail::pred_orF<Pred1T,Pred2T>(
-        static_cast<const Pred1T&>(Pred1), 
-        static_cast<const Pred2T&>(Pred2));
-}
-
-//! predicate negation operator
-/*!
-    Construct the \c class_not predicate. This predicate represents a negation. 
-    \c class_or holds, if of the predicates return false.
-
-    \param Pred The predicate to be negated
-    \return An instance of the \c class_not predicate     
-*/
-template<typename PredT>
-inline boost::algorithm::detail::pred_notF<PredT>
-operator!( const boost::algorithm::detail::predicate_facade<PredT>& Pred )
-{
-    return boost::algorithm::detail::pred_notF<PredT>(static_cast<const PredT&>(Pred)); 
-}
-
 #endif  // BOOST_STRING_PREDICATE_HPP

include/boost/algorithm/string/collection_traits.hpp

@@ -1,268 +0,0 @@
-//  Boost string_algo library collection_traits.hpp header file  -------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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)
-
-// (C) Copyright Thorsten Ottosen 2002-2003. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-//  Orignal idea of container traits was proposed by Jeremy Siek and
-//  Thorsten Ottosen. This implemenetation is lightweighted version
-//  of container_traits adapter for usage with string_algo library
-
-#ifndef BOOST_STRING_COLLECTION_TRAITS_HPP
-#define BOOST_STRING_COLLECTION_TRAITS_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/mpl/apply_if.hpp>
-
-// Implementation
-#include <boost/algorithm/string/detail/collection_traits.hpp>
-
-/*! \file
-    Defines collection_traits class and related free-standing functions.
-    This facility is used to unify the access to different types of collections.
-    It allows the algorithms in the library to work with STL collections, c-style
-    array, null-terminated c-strings (and more) using the same interface.
-*/
-
-namespace boost {
-    namespace algorithm {
-
-//  collection_traits template class -----------------------------------------//
-        
-        //! collection_traits class
-        /*!
-            Collection traits provides uniform access to different types of 
-            collections. This functionality allows to write generic algorithms
-            which work with several different kinds of collections.
-
-            Currently following collection types are supported:
-                - containers with STL compatible container interface ( see ContainerConcept )
-                    ( i.e. \c std::vector<>, \c std::list<>, \c std::string<> ... )
-                - c-style array 
-                   ( \c char[10], \c int[15] ... )
-                - null-terminated c-strings
-                    ( \c char*, \c wchar_T* )
-                - std::pair of iterators 
-                    ( i.e \c std::pair<vector<int>::iterator,vector<int>::iterator> )
-
-            Collection traits provide a external collection interface operations.
-            All are accessible using free-standing functions.
-
-            Following operations are supported:
-                - \c size()
-                - \c empty()
-                - \c begin()
-                - \c end()
-
-            Container traits have somewhat limited functionality on compilers not
-            supporting partial template specialization and partial template ordering.
-        */
-        template< typename T >
-        struct collection_traits
-        {
-        private:
-            typedef BOOST_STRING_TYPENAME ::boost::mpl::apply_if< 
-                    ::boost::algorithm::detail::is_pair<T>, 
-                        detail::pair_container_traits_selector<T>,
-                        BOOST_STRING_TYPENAME ::boost::mpl::apply_if< 
-                        ::boost::is_array<T>, 
-                            detail::array_container_traits_selector<T>,
-                            BOOST_STRING_TYPENAME ::boost::mpl::apply_if<
-                            ::boost::is_pointer<T>,
-                                detail::pointer_container_traits_selector<T>,
-                                detail::default_container_traits_selector<T>
-                            >
-                        > 
-                >::type container_helper_type;
-        public:
-            //! Function type       
-            typedef container_helper_type function_type;        
-            //! Value type
-            typedef BOOST_STRING_TYPENAME 
-                container_helper_type::value_type value_type;
-            //! Size type
-            typedef BOOST_STRING_TYPENAME 
-                container_helper_type::size_type size_type;
-            //! Iterator type
-            typedef BOOST_STRING_TYPENAME 
-                container_helper_type::iterator iterator;
-            //! Const iterator type
-            typedef BOOST_STRING_TYPENAME 
-                container_helper_type::const_iterator const_iterator;
-            //! Result iterator type ( iterator of const_iterator, depending on the constness of the conainer )
-            typedef BOOST_STRING_TYPENAME 
-                container_helper_type::result_iterator result_iterator;
-            //! Difference type
-            typedef BOOST_STRING_TYPENAME 
-                container_helper_type::difference_type difference_type;
-
-        }; // 'collection_traits'
-
-//  collection_traits metafunctions -----------------------------------------//
-
-        //! Container value_type trait
-        /*!
-            Extract the type of elements conained in a container
-        */
-        template< typename C >
-        struct value_type_of
-        {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::value_type type;
-        };
-        
-        //! Container difference trait
-        /*!
-            Extract the container's difference type
-        */
-        template< typename C >
-        struct difference_type_of
-        {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::difference_type type;
-        };
-
-        //! Container iterator trait
-        /*!
-            Extract the container's iterator type
-        */
-        template< typename C >
-        struct iterator_of
-        {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::iterator type;
-        };
-
-        //! Container const_iterator trait
-        /*!
-            Extract the container's const_iterator type
-        */
-        template< typename C >
-        struct const_iterator_of
-        {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::const_iterator type;
-        };
-
-
-        //! Container result_iterator
-        /*!
-            Extract the container's result_iterator type. This type maps to \c C::iterator
-            for mutable container and \c C::const_iterator for const containers.
-        */
-        template< typename C >
-        struct result_iterator_of
-        {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::result_iterator type;
-        };
-
-//  collection_traits related functions -----------------------------------------//
-
-        //! Free-standing size() function
-        /*!
-            Get the size of the container. Uses collection_traits.
-        */
-        template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::size_type
-        size( const C& c )
-        {
-            return collection_traits<C>::function_type::size( c ); 
-        }
-
-        //! Free-standing empty() function
-        /*!
-            Check whenever the container is empty. Uses container traits.
-        */
-        template< typename C >
-        inline bool empty( const C& c )
-        {
-            return collection_traits<C>::function_type::empty( c );
-        }
-
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-        //! Free-standing begin() function
-        /*!
-            Get the begin iterator of the container. Uses collection_traits.
-        */
-        template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::iterator
-        begin( C& c )
-        {
-            return collection_traits<C>::function_type::begin( c ); 
-        }
-
-        //! Free-standing begin() function
-        /*!
-            \overload
-        */
-        template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::const_iterator
-        begin( const C& c )
-        {
-            return collection_traits<C>::function_type::begin( c ); 
-        }
-
-        //! Free-standing end() function
-        /*!
-            Get the begin iterator of the container. Uses collection_traits.
-        */
-        template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::iterator
-        end( C& c )
-        {
-            return collection_traits<C>::function_type::end( c );
-        }
-
-        //! Free-standing end() function
-        /*!
-            \overload           
-        */
-        template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::const_iterator
-        end( const C& c )
-        {
-            return collection_traits<C>::function_type::end( c );
-        }
-
-#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-        //! Free-standing begin() function
-        /*!
-            \overload
-        */
-        template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::result_iterator
-        begin( C& c )
-        {
-            return collection_traits<C>::function_type::begin( c );
-        }
-
-        //! Free-standing end() function
-        /*!
-            \overload
-        */
-        template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::result_iterator
-        end( C& c )
-        {
-            return collection_traits<C>::function_type::end( c );
-        }
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-    } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_COLLECTION_TRAITS_HPP

include/boost/algorithm/string/compare.hpp

@@ -14,7 +14,7 @@
 #include <locale>
 
 /*! \file
-    Defines element comparison predicates. Many algorithms in this library can 
+    Defines element comparison predicates. Many algorithms in this library can
     take an additional argument with a predicate used to compare elements.
     This makes it possible, for instance, to have case insensitive versions
     of the algorithms.
@@ -22,13 +22,13 @@
 
 namespace boost {
     namespace algorithm {
-    
+
         //  is_equal functor  -----------------------------------------------//
 
         //! is_equal functor
         /*!
-            Standard STL equal_to does handle only comparison between arguments
-            of the same type. This is less restrictive version which wraps == operator.
+            Standard STL equal_to only handle comparison between arguments
+            of the same type. This is a less restrictive version which wraps operator ==.
         */
         struct is_equal
         {
@@ -54,24 +54,28 @@ namespace boost {
             /*!
                 \param Loc locales used for comparison
             */
-            is_iequal( const std::locale& Loc=std::locale() ) : 
+            is_iequal( const std::locale& Loc=std::locale() ) :
                 m_Loc( Loc ) {}
 
-            //! Function operator 
+            //! Function operator
             /*!
                 Compare two operands. Case is ignored.
             */
             template< typename T1, typename T2 >
                 bool operator ()( const T1& Arg1, const T2& Arg2 ) const
             {
-                return std::toupper(Arg1,m_Loc)==std::toupper(Arg2,m_Loc);
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    return std::toupper(Arg1)==std::toupper(Arg2);
+                #else
+                    return std::toupper(Arg1,m_Loc)==std::toupper(Arg2,m_Loc);
+                #endif
             }
 
         private:
             std::locale m_Loc;
         };
 
-    } // namespace algorithm 
+    } // namespace algorithm
 
     // pull names to the boost namespace
     using algorithm::is_equal;

include/boost/algorithm/string/concept.hpp

@@ -11,8 +11,9 @@
 #define BOOST_STRING_CONCEPT_HPP
 
 #include <boost/concept_check.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
 
 /*! \file 
     Defines concepts used in string_algo library
@@ -23,8 +24,8 @@ namespace boost {
 
         //! Finder concept
         /*!
-            Defines finder concept. Finder is a functor which selects
-            an arbitraty part of a container. Search is performed on
+            Defines the Finder concept. Finder is a functor which selects
+            an arbitrary part of a string. Search is performed on
             the range specified by starting and ending iterators.
 
             Result of the find operation must be convertible to iterator_range.
@@ -49,7 +50,7 @@ namespace boost {
         
         //! Formatter concept
         /*!
-            Defines formatter concept. Formatter is a functor, which
+            Defines the Formatter concept. Formatter is a functor, which
             takes a result from a finder operation and transforms it
             in a specific way.
 

include/boost/algorithm/string/config.hpp

@@ -11,15 +11,17 @@
 #define BOOST_STRING_CONFIG_HPP
 
 #include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
 
 #ifdef BOOST_STRING_DEDUCED_TYPENAME
 #   error "macro already defined!"
 #endif
 
-#ifdef __BORLANDC__
-#define BOOST_STRING_TYPENAME
-#else
 #define BOOST_STRING_TYPENAME BOOST_DEDUCED_TYPENAME
+
+// Metrowerks workaround
+#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
+#pragma parse_func_templ off
 #endif
 
 #endif  // BOOST_STRING_CONFIG_HPP

include/boost/algorithm/string/detail/case_conv.hpp

@@ -20,7 +20,7 @@ namespace boost {
 
 //  case conversion functors -----------------------------------------------//
 
-            // a tolower functor 
+            // a tolower functor
             template<typename CharT>
             struct to_lowerF : public std::unary_function<CharT, CharT>
             {
@@ -30,13 +30,17 @@ namespace boost {
                 // Operation
                 CharT operator ()( CharT Ch ) const
                 {
-                    return std::tolower( Ch, m_Loc );
+                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                        return std::tolower( Ch);
+                    #else
+                        return std::tolower( Ch, m_Loc );
+                    #endif
                 }
             private:
                 const std::locale& m_Loc;
             };
 
-            // a toupper functor 
+            // a toupper functor
             template<typename CharT>
             struct to_upperF : public std::unary_function<CharT, CharT>
             {
@@ -46,7 +50,11 @@ namespace boost {
                 // Operation
                 CharT operator ()( CharT Ch ) const
                 {
-                    return std::toupper( Ch, m_Loc );
+                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                        return std::toupper( Ch);
+                    #else
+                        return std::toupper( Ch, m_Loc );
+                    #endif
                 }
             private:
                 const std::locale& m_Loc;

include/boost/algorithm/string/detail/classification.hpp

@@ -15,26 +15,19 @@
 #include <functional>
 #include <locale>
 #include <set>
-#include <boost/algorithm/string/collection_traits.hpp>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/algorithm/string/predicate_facade.hpp>
 #include <boost/type_traits/remove_const.hpp>
 
 namespace boost {
     namespace algorithm {
         namespace detail {
 
-//  predicate facade ------------------------------------------------------//
-
-            // Predicate facade
-            /*
-                This class allows to recognize classification
-                predicates, so that they can be combined using
-                composition operators.
-            */
-            template<typename Derived>
-            struct predicate_facade {};
-
 //  classification functors -----------------------------------------------//
-            
+
             // is_classified functor
             struct is_classifiedF :
                 public predicate_facade<is_classifiedF>
@@ -42,7 +35,7 @@ namespace boost {
                 // Boost.Lambda support
                 template <class Args> struct sig { typedef bool type; };
 
-                // Constructor from a locale 
+                // Constructor from a locale
                 is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
                     m_Type(Type), m_Locale(Loc) {}
 
@@ -53,13 +46,21 @@ namespace boost {
                     return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
                 }
 
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    template<>
+                    bool operator()( char const Ch ) const
+                    {
+                        return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch );
+                    }
+                #endif
+
             private:
                 const std::ctype_base::mask m_Type;
                 const std::locale m_Locale;
             };
 
-            // is_any_of functor 
-            /* 
+            // is_any_of functor
+            /*
                 returns true if the value is from the specified set
             */
             template<typename CharT>
@@ -69,26 +70,26 @@ namespace boost {
                 // Boost.Lambda support
                 template <class Args> struct sig { typedef bool type; };
 
-                // Constructor 
-                template< typename SeqT >
-                is_any_ofF( const SeqT& Seq ) : 
-                    m_Set( begin(Seq), end(Seq) ) {}
-                
+                // Constructor
+                template<typename RangeT>
+                is_any_ofF( const RangeT& Range ) :
+                    m_Set( begin(Range), end(Range) ) {}
+
                 // Operation
                 template<typename Char2T>
                 bool operator()( Char2T Ch ) const
                 {
                     return m_Set.find(Ch)!=m_Set.end();
                 }
-            
+
             private:
                 // set cannot operate on const value-type
                 typedef typename remove_const<CharT>::type set_value_type;
-                std::set<set_value_type> m_Set;                
+                std::set<set_value_type> m_Set;
             };
 
-            // is_from_range functor 
-            /* 
+            // is_from_range functor
+            /*
                 returns true if the value is from the specified range.
                 (i.e. x>=From && x>=To)
             */
@@ -99,16 +100,16 @@ namespace boost {
                 // Boost.Lambda support
                 template <class Args> struct sig { typedef bool type; };
 
-                // Constructor 
+                // Constructor
                 is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
-                
+
                 // Operation
                 template<typename Char2T>
                 bool operator()( Char2T Ch ) const
                 {
-                    return ( m_From <= Ch ) && ( Ch <= m_To ); 
+                    return ( m_From <= Ch ) && ( Ch <= m_To );
                 }
-            
+
             private:
                 CharT m_From;
                 CharT m_To;
@@ -130,11 +131,11 @@ namespace boost {
 
                 // Operation
                 template<typename CharT>
-                bool operator()( CharT Ch ) const 
+                bool operator()( CharT Ch ) const
                 {
                     return m_Pred1(Ch) && m_Pred2(Ch);
                 }
-            
+
             private:
                 Pred1T m_Pred1;
                 Pred2T m_Pred2;
@@ -155,11 +156,11 @@ namespace boost {
 
                 // Operation
                 template<typename CharT>
-                bool operator()( CharT Ch ) const 
+                bool operator()( CharT Ch ) const
                 {
                     return m_Pred1(Ch) || m_Pred2(Ch);
                 }
-            
+
             private:
                 Pred1T m_Pred1;
                 Pred2T m_Pred2;
@@ -179,11 +180,11 @@ namespace boost {
 
                 // Operation
                 template<typename CharT>
-                bool operator()( CharT Ch ) const 
+                bool operator()( CharT Ch ) const
                 {
                     return !m_Pred(Ch);
                 }
-            
+
             private:
                 PredT m_Pred;
             };

include/boost/algorithm/string/detail/collection_traits.hpp

@@ -1,621 +0,0 @@
-//  Boost string_algo library collection_traits.hpp header file  -----------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_DETAIL_COLLECTION_TRAITS_HPP
-#define BOOST_STRING_DETAIL_COLLECTION_TRAITS_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <cstddef>
-#include <string>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/mpl/apply_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/mpl/fold.hpp>
-#include <boost/detail/iterator.hpp>
-#include <boost/algorithm/string/yes_no_type.hpp>
-
-// Container traits implementation ---------------------------------------------------------
-
-namespace boost {
-    namespace algorithm {
-        namespace detail {
-
-// Default collection traits -----------------------------------------------------------------
-
-            // Default collection helper 
-            /*
-                Wraps std::container compliant containers
-            */
-            template< typename ContainerT >     
-            struct default_container_traits
-            {
-                typedef BOOST_STRING_TYPENAME ContainerT::value_type value_type;
-                typedef BOOST_STRING_TYPENAME ContainerT::iterator iterator;
-                typedef BOOST_STRING_TYPENAME ContainerT::const_iterator const_iterator;
-                typedef BOOST_STRING_TYPENAME 
-                    ::boost::mpl::if_< ::boost::is_const<ContainerT>,
-                        const_iterator,
-                        iterator 
-                    >::type result_iterator;
-                typedef BOOST_STRING_TYPENAME ContainerT::difference_type difference_type;
-                typedef BOOST_STRING_TYPENAME ContainerT::size_type size_type;
-                
-                // static operations
-                template< typename C >
-                static size_type size( const C& c )
-                {
-                    return c.size();
-                }
-
-                template< typename C >
-                static bool empty( const C& c )
-                {
-                    return c.empty();
-                }
-
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-                template< typename C >
-                static iterator begin( C& c )
-                {
-                    return c.begin();
-                }
-
-                template< typename C >
-                static const_iterator begin( const C& c )
-                {
-                    return c.begin();
-                }
-
-                template< typename C >
-                static iterator end( C& c )
-                {
-                    return c.end();
-                }
-
-                template< typename C >
-                static const_iterator end( const C& c )
-                {
-                    return c.end();
-                }
-
-#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-                template< typename C >
-                static result_iterator begin( C& c )
-                {
-                    return c.begin();
-                }
-
-                template< typename C >
-                static result_iterator end( C& c )
-                {
-                    return c.end();
-                }
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING    
-
-            }; 
-
-            template<typename T>
-            struct default_container_traits_selector
-            {
-                typedef default_container_traits<T> type;
-            };
-
-// Pair container traits ---------------------------------------------------------------------
-                    
-            // pair selector
-            template< typename T, typename U >
-            yes_type is_pair_impl( const std::pair<T,U>* );
-            no_type is_pair_impl( ... );
-
-            template<typename T> struct is_pair
-            {
-            private:
-                static T* t;
-            public:
-                BOOST_STATIC_CONSTANT( bool, value=
-                    sizeof(is_pair_impl(t))==sizeof(yes_type) );
-            };
-
-            // pair helper
-            template< typename PairT >
-            struct pair_container_traits
-            {
-                typedef BOOST_STRING_TYPENAME PairT::first_type element_type;
-
-                typedef BOOST_STRING_TYPENAME ::boost::detail::
-                    iterator_traits<element_type>::value_type value_type;
-                typedef std::size_t size_type;
-                typedef BOOST_STRING_TYPENAME ::boost::detail::
-                    iterator_traits<element_type>::difference_type difference_type;
-
-                typedef element_type iterator;
-                typedef element_type const_iterator;
-                typedef element_type result_iterator;
-
-                // static operations
-                template< typename P >
-                static size_type size( const P& p )
-                {
-                    difference_type diff = std::distance( p.first, p.second );
-                    if ( diff < 0 ) 
-                        return 0;
-                    else
-                        return diff;
-                }
-
-                template< typename P >
-                static bool empty( const P& p )
-                {
-                    return p.first==p.second;
-                }
-
-                template< typename P > 
-                static const_iterator begin( const P& p )
-                {
-                    return p.first;
-                }
-
-                template< typename P >
-                static const_iterator end( const P& p )
-                {
-                    return p.second;
-                }
-            }; // 'pair_container_helper'
-
-            template<typename T>
-            struct pair_container_traits_selector
-            {
-                typedef pair_container_traits<T> type;
-            };
-
-// Array container traits ---------------------------------------------------------------
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-            // array traits ( partial specialization )
-            template< typename T >
-            struct array_traits;
-
-            template< typename T, std::size_t sz >
-            struct array_traits<T[sz]>
-            {
-                // typedef
-                typedef T* iterator;
-                typedef const T* const_iterator;
-                typedef T value_type;
-                typedef std::size_t size_type;
-                typedef std::ptrdiff_t difference_type;
-
-                // size of the array ( static );
-                BOOST_STATIC_CONSTANT( size_type, array_size = sz );
-            };
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-            // array traits ( no partial specialization )
-            /*
-                without parial specialization we are able to
-                provide support only for a limited number of
-                types. Currently the primitive numeric types 
-                are supported
-            */
-            template< typename T, typename BaseT >
-            struct array_traits_impl
-            {
-                typedef BaseT value_type;
-                typedef BaseT* iterator;
-                typedef const BaseT* const_iterator;
-                typedef std::size_t size_type;
-                typedef std::ptrdiff_t difference_type;
-
-                // size of the array
-                BOOST_STATIC_CONSTANT( size_type, array_size = sizeof(T)/sizeof(BaseT) );
-            };
-            
-            template< typename T, typename BaseT >
-            struct array_traits_impl_selector
-            {
-                typedef array_traits_impl<T,BaseT> type;
-            };
-
-            struct array_traits_void
-            {
-                typedef void type;
-            };
-
-            template< typename T, typename BaseT >
-            struct array_traits_cv_selector
-            {
-                typedef BOOST_STRING_TYPENAME 
-                    ::boost::mpl::apply_if< 
-                        ::boost::is_convertible<T,BaseT*>,
-                        array_traits_impl_selector<T,BaseT>,
-                        ::boost::mpl::apply_if< 
-                            ::boost::is_convertible<T,const BaseT*>,
-                                array_traits_impl_selector<T, const BaseT>,
-                                ::boost::mpl::apply_if< 
-                                    ::boost::is_convertible<T, volatile BaseT*>,
-                                    array_traits_impl_selector<T, volatile BaseT>,
-                                    array_traits_impl_selector<T, const volatile BaseT>
-                                >
-                            >
-                    >::type type;
-            };
-
-            template< typename T >
-            struct array_traits_select
-            {
-                template< typename T1, typename T2 >
-                struct apply
-                {
-                    typedef BOOST_STRING_TYPENAME
-                        ::boost::mpl::apply_if< 
-                            ::boost::is_convertible<T,const volatile T2*>,
-                            array_traits_cv_selector<T,T2>,
-                            ::boost::mpl::identity<T1> >::type type;
-                };
-            };
-
-            template< typename T >
-            struct array_traits_selector 
-            {
-            private:
-                // supported array base types
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-                typedef BOOST_STRING_TYPENAME
-                    ::boost::mpl::vector10<
-                        wchar_t,
-#else // BOOST_NO_INTRINSIC_WCHAR_T
-                typedef BOOST_STRING_TYPENAME
-                    ::boost::mpl::vector9<
-#endif // BOOST_NO_INTRINSIC_WCHAR_T
-                        char,
-                        signed char,
-                        unsigned char,
-                        signed short,
-                        unsigned short,
-                        signed int,
-                        unsigned int,
-                        signed long,
-                        unsigned long
-                >::type array_base_types;
-
-            public:
-                typedef BOOST_STRING_TYPENAME
-                    ::boost::mpl::fold<
-                        array_base_types,
-                        ::boost::algorithm::detail::array_traits_void,
-                        ::boost::algorithm::detail::array_traits_select<T> >::type type;
-            };
-
-            template< typename T >
-            struct array_traits
-            {
-                typedef BOOST_STRING_TYPENAME
-                    array_traits_selector<T>::type traits_type;
-
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::value_type value_type;
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::iterator iterator;
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::const_iterator const_iterator;
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::size_type size_type;
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::difference_type difference_type;
-
-                BOOST_STATIC_CONSTANT( size_type, array_size = traits_type::array_size );
-            };
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-            
-            // array lenght resolving
-            /*
-                Lenght of string contained in a static array could
-                be different from the size of the array.
-                For string processing we need the lenght without
-                terminating 0.
-
-                Therefore, the lenght is calulated for char and wchar_t
-                using char_traits, rather then simply returning
-                the array size.
-            */
-            template< typename T >
-            struct array_length_selector
-            {
-                template< typename TraitsT >
-                struct array_length
-                {
-                    typedef BOOST_STRING_TYPENAME 
-                        TraitsT::size_type size_type;
-
-                    BOOST_STATIC_CONSTANT(
-                        size_type,
-                        array_size=TraitsT::array_size );
-
-                    template< typename A >
-                    static size_type length( const A& )
-                    {
-                        return array_size;
-                    }
-
-                    template< typename A >
-                    static bool empty( const A& )
-                    {
-                        return array_size==0;
-                    }
-                };
-            };
-
-            // specialization for char
-            template<>
-            struct array_length_selector<char>
-            {
-                template< typename TraitsT >
-                struct array_length
-                {
-                    typedef BOOST_STRING_TYPENAME 
-                        TraitsT::size_type size_type;
-
-                    template< typename A >
-                    static size_type length( const A& a )
-                    {
-                        if ( a==0 ) 
-                            return 0;
-                        else
-                            return std::char_traits<char>::length(a);
-                    }
-                    
-                    template< typename A >
-                    static bool empty( const A& a )
-                    {
-                        return a==0 || a[0]==0;
-                    }
-                };
-            };
-
-            // specialization for wchar_t
-            template<>
-            struct array_length_selector<wchar_t>
-            {
-                template< typename TraitsT >
-                struct array_length
-                {
-                    typedef BOOST_STRING_TYPENAME 
-                        TraitsT::size_type size_type;
-
-                    template< typename A >
-                    static size_type length( const A& a )
-                    {
-                        if ( a==0 ) 
-                            return 0;
-                        else
-                            return std::char_traits<wchar_t>::length(a);
-                    }
-
-                    template< typename A >
-                    static bool empty( const A& a )
-                    {
-                        return a==0 || a[0]==0;
-                    }
-                };
-            };
-
-            template< typename T >
-            struct array_container_traits
-            {
-            private:
-                // resolve array traits
-                typedef array_traits<T> traits_type;
-
-            public:
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::value_type value_type;
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::iterator iterator;
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::const_iterator const_iterator;
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::size_type size_type;
-                typedef BOOST_STRING_TYPENAME
-                    traits_type::difference_type difference_type;
-
-                typedef BOOST_STRING_TYPENAME
-                    ::boost::mpl::if_< ::boost::is_const<T>,
-                        const_iterator,
-                        iterator 
-                    >::type result_iterator;
-                
-            private:
-                // resolve array size
-                typedef BOOST_STRING_TYPENAME
-                    ::boost::remove_cv<value_type>::type char_type;
-                typedef BOOST_STRING_TYPENAME
-                    array_length_selector<char_type>::
-                        BOOST_NESTED_TEMPLATE array_length<traits_type> array_length_type;
-
-            public:
-                BOOST_STATIC_CONSTANT( size_type, array_size = traits_type::array_size );
-
-                // static operations
-                template< typename A >
-                static size_type size( const A& a )
-                {
-                    return array_length_type::length(a);
-                }
-
-                template< typename A >
-                static bool empty( const A& a )
-                {
-                    return array_length_type::empty(a);
-                }
-                
-
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-                template< typename A >
-                static iterator begin( A& a )
-                {
-                    return a;
-                }
-
-                template< typename A >
-                static const_iterator begin( const A& a )
-                {
-                    return a;
-                }
-
-                template< typename A >
-                static iterator end( A& a )
-                {
-                    return a+array_length_type::length(a);
-                }
-
-                template< typename A >
-                static const_iterator end( const A& a )
-                {
-                    return a+array_length_type::length(a);
-                }
-
-#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-                template< typename A >
-                static result_iterator begin( A& a )
-                {
-                    return a;
-                }
-
-                template< typename A >
-                static result_iterator end( A& a )
-                {
-                    return a+array_length_type::length(a);
-                }
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING    
-
-            }; 
-
-            template<typename T>
-            struct array_container_traits_selector
-            {
-                typedef array_container_traits<T> type;
-            };
-
-// Pointer container traits ---------------------------------------------------------------
-
-            template<typename T>
-            struct pointer_container_traits
-            {
-                typedef BOOST_STRING_TYPENAME
-                    ::boost::remove_pointer<T>::type value_type;
-
-                typedef BOOST_STRING_TYPENAME
-                    ::boost::remove_cv<value_type>::type char_type;
-                typedef ::std::char_traits<char_type> char_traits;
-
-                typedef value_type* iterator;
-                typedef const value_type* const_iterator;
-                typedef std::ptrdiff_t difference_type;
-                typedef std::size_t size_type;
-
-                typedef BOOST_STRING_TYPENAME
-                    ::boost::mpl::if_< ::boost::is_const<T>,
-                        const_iterator,
-                        iterator 
-                    >::type result_iterator;
-
-                // static operations
-                template< typename P >
-                static size_type size( const P& p )
-                {
-                    if ( p==0 ) 
-                        return 0;
-                    else
-                        return char_traits::length(p);
-                }
-
-                template< typename P >
-                static bool empty( const P& p )
-                {
-                    return p==0 || p[0]==0;
-                }
-
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-                template< typename P >
-                static iterator begin( P& p )
-                {
-                    return p;
-                }
-
-                template< typename P >
-                static const_iterator begin( const P& p )
-                {
-                    return p;
-                }
-
-                template< typename P >
-                static iterator end( P& p )
-                {
-                    if ( p==0 )
-                        return p;
-                    else
-                        return p+char_traits::length(p);
-                }
-
-                template< typename P >
-                static const_iterator end( const P& p )
-                {
-                    if ( p==0 )
-                        return p;
-                    else
-                        return p+char_traits::length(p);
-                }
-
-#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-                template< typename P >
-                static result_iterator begin( P& p )
-                {
-                    return p;
-                }
-
-                template< typename P >
-                static result_iterator end( P& p )
-                {
-                    if ( p==0 )
-                        return p;
-                    else
-                        return p+char_traits::length(p);
-                }
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING    
-            }; 
-
-            template<typename T>
-            struct pointer_container_traits_selector
-            {
-                typedef pointer_container_traits<T> type;
-            };
-
-        } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-
-#endif  // BOOST_STRING_DETAIL_COLLECTION_HPP

include/boost/algorithm/string/detail/find_format.hpp

@@ -11,7 +11,9 @@
 #define BOOST_STRING_FIND_FORMAT_DETAIL_HPP
 
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/iterator.hpp>
 #include <boost/algorithm/string/detail/find_format_store.hpp>
 #include <boost/algorithm/string/detail/replace_storage.hpp>
 
@@ -60,7 +62,7 @@ namespace boost {
             {       
                 typedef find_format_store<
                     BOOST_STRING_TYPENAME 
-                        const_iterator_of<InputT>::type, 
+                        range_const_iterator<InputT>::type, 
                         FormatterT,
                         FormatResultT > store_type;
 
@@ -121,7 +123,7 @@ namespace boost {
             {
                 typedef find_format_store<
                     BOOST_STRING_TYPENAME 
-                        const_iterator_of<InputT>::type, 
+                        range_const_iterator<InputT>::type, 
                         FormatterT,
                         FormatResultT > store_type;
 
@@ -174,14 +176,14 @@ namespace boost {
                 typename FormatResultT >
             inline void find_format_impl2( 
                 InputT& Input,
-                FinderT Finder,
+                FinderT,
                 FormatterT Formatter,
                 const FindResultT& FindResult,
                 const FormatResultT& FormatResult)
             {
                 typedef find_format_store<
                     BOOST_STRING_TYPENAME 
-                        iterator_of<InputT>::type, 
+                        range_iterator<InputT>::type, 
                         FormatterT,
                         FormatResultT > store_type;
 

include/boost/algorithm/string/detail/find_format_all.hpp

@@ -11,7 +11,9 @@
 #define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
 
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/value_type.hpp>
 #include <boost/algorithm/string/detail/find_format_store.hpp>
 #include <boost/algorithm/string/detail/replace_storage.hpp>
 
@@ -59,7 +61,7 @@ namespace boost {
                 const FormatResultT& FormatResult )
             {       
                 typedef BOOST_STRING_TYPENAME 
-                    const_iterator_of<InputT>::type input_iterator_type; 
+                    range_const_iterator<InputT>::type input_iterator_type; 
 
                 typedef find_format_store<
                         input_iterator_type, 
@@ -72,7 +74,7 @@ namespace boost {
                 // Initialize last match
                 input_iterator_type LastMatch=begin(Input);
 
-                // Iterate throug all matches
+                // Iterate through all matches
                 while( M )
                 {
                     // Copy the beginning of the sequence
@@ -126,7 +128,7 @@ namespace boost {
                 const FormatResultT& FormatResult)
             {
                 typedef BOOST_STRING_TYPENAME 
-                    const_iterator_of<InputT>::type input_iterator_type; 
+                    range_const_iterator<InputT>::type input_iterator_type; 
 
                 typedef find_format_store<
                         input_iterator_type, 
@@ -142,7 +144,7 @@ namespace boost {
                 // Output temporary
                 InputT Output;
 
-                // Iterate throug all matches
+                // Iterate through all matches
                 while( M )
                 {
                     // Copy the beginning of the sequence
@@ -196,7 +198,7 @@ namespace boost {
                 FormatResultT FormatResult)
             {
                 typedef BOOST_STRING_TYPENAME 
-                    iterator_of<InputT>::type input_iterator_type; 
+                    range_iterator<InputT>::type input_iterator_type; 
                 typedef find_format_store<
                         input_iterator_type, 
                         FormatterT,
@@ -207,7 +209,7 @@ namespace boost {
           
                 // Instantiate replacement storage
                 std::deque<
-                    BOOST_STRING_TYPENAME value_type_of<InputT>::type> Storage;
+                    BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
 
                 // Initialize replacement iterators
                 input_iterator_type InsertIt=begin(Input);

include/boost/algorithm/string/detail/find_format_store.hpp

@@ -11,8 +11,7 @@
 #define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
 
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+#include <boost/range/iterator_range.hpp>
 
 namespace boost {
     namespace algorithm {
@@ -36,7 +35,7 @@ namespace boost {
             public:
                 // Construction
                 find_format_store( 
-                        const base_type FindResult,
+                        const base_type& FindResult,
                         const format_result_type& FormatResult,
                         const formatter_type& Formatter ) :
                     base_type(FindResult),

include/boost/algorithm/string/detail/find_iterator.hpp

@@ -10,70 +10,16 @@
 #ifndef BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
 #define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
 
-
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+#include <boost/range/iterator_range.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/iterator_categories.hpp>
+#include <boost/function.hpp>
 
 namespace boost {
     namespace algorithm { 
         namespace detail {
 
-//  finder virtualizer -----------------------------------------------//
-
-            template<typename IteratorT>
-            struct virtual_finder
-            {
-                // typedefs
-                typedef IteratorT input_iterator_type;
-                typedef iterator_range<IteratorT> match_type;
-
-                // virtual destructor
-                virtual ~virtual_finder() {}
-
-                // clone
-                virtual virtual_finder* clone() const=0;
-
-                // operation
-                virtual match_type do_find( 
-                    input_iterator_type Begin,
-                    input_iterator_type End ) const=0;
-            };
-
-            template<typename IteratorT, typename FinderT>
-            struct virtual_finder_typed : public virtual_finder<IteratorT>
-            {
-                // typedefs
-                typedef virtual_finder<IteratorT> base_type;
-                typedef BOOST_STRING_TYPENAME 
-                    base_type::input_iterator_type input_iterator_type;
-                typedef BOOST_STRING_TYPENAME 
-                    base_type::match_type match_type;
-
-                // constuction
-                virtual_finder_typed( FinderT Finder ) : m_Finder(Finder) {}
-
-                // clone
-                virtual_finder_typed* clone() const
-                {
-                    return new virtual_finder_typed(m_Finder);
-                }
-
-                // operation
-                virtual match_type do_find( 
-                    input_iterator_type Begin,
-                    input_iterator_type End ) const
-                {
-                    return m_Finder(Begin,End);
-                }
-
-            private:
-                // Finder
-                FinderT m_Finder;
-            };
-
-
 //  find_iterator base -----------------------------------------------//
 
             // Find iterator base
@@ -84,40 +30,36 @@ namespace boost {
                 // typedefs
                 typedef IteratorT input_iterator_type;
                 typedef iterator_range<IteratorT> match_type;
-
+                typedef function2<
+                    match_type, 
+                    input_iterator_type, 
+                    input_iterator_type> finder_type;
+                
             protected:
             // Protected construction/destruction
 
                 // Default constructor
-                find_iterator_base() : m_pFinder(0) {};
+                find_iterator_base() {};
                 // Copy construction
                 find_iterator_base( const find_iterator_base& Other ) :
-                    m_pFinder(0)
-                {
-                    if ( Other.m_pFinder )
-                    {
-                        m_pFinder=Other.m_pFinder->clone();
-                    }
-                }
+                    m_Finder(Other.m_Finder) {}
+                
                 // Constructor
                 template<typename FinderT>
                 find_iterator_base( FinderT Finder, int ) :
-                    m_pFinder( new virtual_finder_typed<IteratorT,FinderT>(Finder) ) {}
+                    m_Finder(Finder) {}
 
                 // Destructor
-                ~find_iterator_base()
-                {
-                    if (m_pFinder) delete m_pFinder;
-                }
+                ~find_iterator_base() {}
 
                 // Find operation
                 match_type do_find( 
                     input_iterator_type Begin,
                     input_iterator_type End ) const
                 {
-                    if (m_pFinder)
+                    if (!m_Finder.empty())
                     {
-                        return m_pFinder->do_find(Begin,End);
+                        return m_Finder(Begin,End);
                     }
                     else
                     {
@@ -128,12 +70,12 @@ namespace boost {
                 // Check
                 bool is_null() const
                 {
-                    return !m_pFinder;
+                    return m_Finder.empty();
                 }
 
             private:
                 // Finder
-                virtual_finder<IteratorT>* m_pFinder;
+                finder_type m_Finder;
             };
 
        } // namespace detail

include/boost/algorithm/string/detail/finder.hpp

@@ -13,8 +13,11 @@
 #include <boost/algorithm/string/config.hpp>
 #include <boost/algorithm/string/constants.hpp>
 #include <boost/detail/iterator.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/empty.hpp>
 
 namespace boost {
     namespace algorithm {
@@ -25,7 +28,7 @@ namespace boost {
 
             // find a subsequence in the sequence ( functor )
             /*
-                Returns a pair <begin,end> marking the subsequence in the sequence. 
+                Returns a pair <begin,end> marking the subsequence in the sequence.
                 If the find fails, functor returns <End,End>
             */
             template<typename SearchIteratorT,typename PredicateT>
@@ -35,9 +38,9 @@ namespace boost {
 
                 // Construction
                 template< typename SearchT >
-                first_finderF( const SearchT& Search, PredicateT Comp ) : 
+                first_finderF( const SearchT& Search, PredicateT Comp ) :
                     m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
-                first_finderF( 
+                first_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
                         PredicateT Comp ) :
@@ -46,8 +49,8 @@ namespace boost {
                 // Operation
                 template< typename ForwardIteratorT >
                 iterator_range<ForwardIteratorT>
-                operator()( 
-                    ForwardIteratorT Begin, 
+                operator()(
+                    ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
                 {
                     typedef iterator_range<ForwardIteratorT> result_type;
@@ -58,8 +61,8 @@ namespace boost {
                         OuterIt!=End;
                         ++OuterIt)
                     {
-                        // Sanity check 
-                        if( empty(m_Search) )  
+                        // Sanity check
+                        if( boost::empty(m_Search) )
                             return result_type( End, End );
 
                         input_iterator_type InnerIt=OuterIt;
@@ -68,7 +71,7 @@ namespace boost {
                             InnerIt!=End && SubstrIt!=m_Search.end();
                             ++InnerIt,++SubstrIt)
                         {
-                            if( !( m_Comp(*InnerIt,*SubstrIt) ) ) 
+                            if( !( m_Comp(*InnerIt,*SubstrIt) ) )
                                 break;
                         }
 
@@ -89,7 +92,7 @@ namespace boost {
 
             // find the last match a subsequnce in the sequence ( functor )
             /*
-                Returns a pair <begin,end> marking the subsequence in the sequence. 
+                Returns a pair <begin,end> marking the subsequence in the sequence.
                 If the find fails, returns <End,End>
             */
             template<typename SearchIteratorT, typename PredicateT>
@@ -102,9 +105,9 @@ namespace boost {
 
                 // Construction
                 template< typename SearchT >
-                last_finderF( const SearchT& Search, PredicateT Comp ) : 
+                last_finderF( const SearchT& Search, PredicateT Comp ) :
                     m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
-                last_finderF( 
+                last_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
                         PredicateT Comp ) :
@@ -113,34 +116,34 @@ namespace boost {
                 // Operation
                 template< typename ForwardIteratorT >
                 iterator_range<ForwardIteratorT>
-                operator()( 
-                    ForwardIteratorT Begin, 
+                operator()(
+                    ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
                 {
                     typedef iterator_range<ForwardIteratorT> result_type;
 
-                    if( empty(m_Search) )
+                    if( boost::empty(m_Search) )
                         return result_type( End, End );
 
                     typedef BOOST_STRING_TYPENAME boost::detail::
                         iterator_traits<ForwardIteratorT>::iterator_category category;
 
                     return findit( Begin, End, category() );
-                }   
+                }
 
             private:
                 // forward iterator
                 template< typename ForwardIteratorT >
                 iterator_range<ForwardIteratorT>
-                findit( 
-                    ForwardIteratorT Begin, 
-                    ForwardIteratorT End, 
+                findit(
+                    ForwardIteratorT Begin,
+                    ForwardIteratorT End,
                     std::forward_iterator_tag ) const
                 {
                     typedef ForwardIteratorT input_iterator_type;
                     typedef iterator_range<ForwardIteratorT> result_type;
 
-                    first_finder_type first_finder( 
+                    first_finder_type first_finder(
                         m_Search.begin(), m_Search.end(), m_Comp );
 
                     result_type M=first_finder( Begin, End );
@@ -158,9 +161,9 @@ namespace boost {
                 // bidirectional iterator
                 template< typename ForwardIteratorT >
                 iterator_range<ForwardIteratorT>
-                findit( 
-                    ForwardIteratorT Begin, 
-                    ForwardIteratorT End, 
+                findit(
+                    ForwardIteratorT Begin,
+                    ForwardIteratorT End,
                     std::bidirectional_iterator_tag ) const
                 {
                     typedef iterator_range<ForwardIteratorT> result_type;
@@ -178,7 +181,7 @@ namespace boost {
                             InnerIt!=End && SubstrIt!=m_Search.end();
                             ++InnerIt,++SubstrIt)
                         {
-                            if( !( m_Comp(*InnerIt,*SubstrIt) ) ) 
+                            if( !( m_Comp(*InnerIt,*SubstrIt) ) )
                                 break;
                         }
 
@@ -194,12 +197,12 @@ namespace boost {
                 iterator_range<search_iterator_type> m_Search;
                 PredicateT m_Comp;
             };
-    
+
 //  find n-th functor -----------------------------------------------//
 
             // find the n-th match of a subsequnce in the sequence ( functor )
             /*
-                Returns a pair <begin,end> marking the subsequence in the sequence. 
+                Returns a pair <begin,end> marking the subsequence in the sequence.
                 If the find fails, returns <End,End>
             */
             template<typename SearchIteratorT, typename PredicateT>
@@ -212,50 +215,50 @@ namespace boost {
 
                 // Construction
                 template< typename SearchT >
-                nth_finderF( 
-                        const SearchT& Search, 
+                nth_finderF(
+                        const SearchT& Search,
                         unsigned int Nth,
-                        PredicateT Comp) : 
-                    m_Search(begin(Search), end(Search)), 
+                        PredicateT Comp) :
+                    m_Search(begin(Search), end(Search)),
                     m_Nth(Nth),
                     m_Comp(Comp) {}
-                nth_finderF( 
+                nth_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
                         unsigned int Nth,
                         PredicateT Comp) :
-                    m_Search(SearchBegin, SearchEnd), 
+                    m_Search(SearchBegin, SearchEnd),
                     m_Nth(Nth),
                     m_Comp(Comp) {}
 
                 // Operation
                 template< typename ForwardIteratorT >
                 iterator_range<ForwardIteratorT>
-                operator()( 
-                    ForwardIteratorT Begin, 
+                operator()(
+                    ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
                 {
                     typedef ForwardIteratorT input_iterator_type;
                     typedef iterator_range<ForwardIteratorT> result_type;
 
-                    // Sanity check 
-                    if( empty(m_Search) )  
+                    // Sanity check
+                    if( boost::empty(m_Search) )
                         return result_type( End, End );
 
-                    // Instantiate find funtor 
-                    first_finder_type first_finder( 
+                    // Instantiate find funtor
+                    first_finder_type first_finder(
                         m_Search.begin(), m_Search.end(), m_Comp );
 
                     result_type M( Begin, Begin );
 
                     for( unsigned int n=0; n<=m_Nth; ++n )
                     {
-                        // find next match        
+                        // find next match
                         M=first_finder( end(M), End );
 
                         if ( !M )
                         {
-                            // Subsequence not found, return 
+                            // Subsequence not found, return
                             return M;
                         }
                     }
@@ -273,8 +276,8 @@ namespace boost {
 
             // find a head in the sequence ( functor )
             /*
-                This functor find a head of the specified range. For 
-                a specified N, the head is a subsequence of N starting 
+                This functor find a head of the specified range. For
+                a specified N, the head is a subsequence of N starting
                 elements of the range.
             */
             struct head_finderF
@@ -285,8 +288,8 @@ namespace boost {
                 // Operation
                 template< typename ForwardIteratorT >
                 iterator_range<ForwardIteratorT>
-                operator()( 
-                    ForwardIteratorT Begin, 
+                operator()(
+                    ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
                 {
                     typedef BOOST_STRING_TYPENAME boost::detail::
@@ -299,7 +302,7 @@ namespace boost {
                 // Find operation implementation
                 template< typename ForwardIteratorT >
                     iterator_range<ForwardIteratorT>
-                findit( 
+                findit(
                     ForwardIteratorT Begin,
                     ForwardIteratorT End,
                     std::forward_iterator_tag ) const
@@ -309,15 +312,15 @@ namespace boost {
 
                     input_iterator_type It=Begin;
                     for(
-                        unsigned int Index=0; 
+                        unsigned int Index=0;
                         Index<m_N && It!=End; ++Index,++It ) {};
-    
+
                     return result_type( Begin, It );
                 }
 
                 template< typename ForwardIteratorT >
                     iterator_range<ForwardIteratorT>
-                findit( 
+                findit(
                     ForwardIteratorT Begin,
                     ForwardIteratorT End,
                     std::random_access_iterator_tag ) const
@@ -339,8 +342,8 @@ namespace boost {
 
             // find a tail in the sequence ( functor )
             /*
-                This functor find a tail of the specified range. For 
-                a specified N, the head is a subsequence of N starting 
+                This functor find a tail of the specified range. For
+                a specified N, the head is a subsequence of N starting
                 elements of the range.
             */
             struct tail_finderF
@@ -351,8 +354,8 @@ namespace boost {
                 // Operation
                 template< typename ForwardIteratorT >
                 iterator_range<ForwardIteratorT>
-                operator()( 
-                    ForwardIteratorT Begin, 
+                operator()(
+                    ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
                 {
                     typedef BOOST_STRING_TYPENAME boost::detail::
@@ -365,7 +368,7 @@ namespace boost {
                 // Find operation implementation
                 template< typename ForwardIteratorT >
                     iterator_range<ForwardIteratorT>
-                findit( 
+                findit(
                     ForwardIteratorT Begin,
                     ForwardIteratorT End,
                     std::forward_iterator_tag ) const
@@ -373,10 +376,10 @@ namespace boost {
                     typedef ForwardIteratorT input_iterator_type;
                     typedef iterator_range<ForwardIteratorT> result_type;
 
-                    unsigned int Index=0; 
+                    unsigned int Index=0;
                     input_iterator_type It=Begin;
                     input_iterator_type It2=Begin;
-                    
+
                     // Advance It2 by N incremets
                     for( Index=0; Index<m_N && It2!=End; ++Index,++It2 ) {};
 
@@ -388,7 +391,7 @@ namespace boost {
 
                 template< typename ForwardIteratorT >
                     iterator_range<ForwardIteratorT>
-                findit( 
+                findit(
                     ForwardIteratorT Begin,
                     ForwardIteratorT End,
                     std::bidirectional_iterator_tag ) const
@@ -398,15 +401,15 @@ namespace boost {
 
                     input_iterator_type It=End;
                     for(
-                        unsigned int Index=0; 
+                        unsigned int Index=0;
                         Index<m_N && It!=Begin; ++Index,--It ) {};
-    
+
                     return result_type( It, End );
                 }
 
                 template< typename ForwardIteratorT >
                     iterator_range<ForwardIteratorT>
-                findit( 
+                findit(
                     ForwardIteratorT Begin,
                     ForwardIteratorT End,
                     std::random_access_iterator_tag ) const
@@ -414,7 +417,7 @@ namespace boost {
                     typedef ForwardIteratorT input_iterator_type;
                     typedef iterator_range<ForwardIteratorT> result_type;
 
-                    if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < m_N ) )  
+                    if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < m_N ) )
                         return result_type( Begin, End );
 
                     return result_type( End-m_N, End );
@@ -434,29 +437,29 @@ namespace boost {
                 with an exception that it return range instead of a single
                 iterator.
 
-                If bCompress is set to true, adjacent matching tokens are 
+                If bCompress is set to true, adjacent matching tokens are
                 concatenated into one match.
             */
             template< typename PredicateT >
             struct token_finderF
             {
                 // Construction
-                token_finderF( 
-                    PredicateT Pred, 
-                    token_compress_mode_type eCompress=token_compress_off ) : 
+                token_finderF(
+                    PredicateT Pred,
+                    token_compress_mode_type eCompress=token_compress_off ) :
                         m_Pred(Pred), m_eCompress(eCompress) {}
 
                 // Operation
                 template< typename ForwardIteratorT >
                 iterator_range<ForwardIteratorT>
-                operator()( 
-                    ForwardIteratorT Begin, 
+                operator()(
+                    ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
                 {
                     typedef iterator_range<ForwardIteratorT> result_type;
 
                     ForwardIteratorT It=std::find_if( Begin, End, m_Pred );
-                
+
                     if( It==End )
                     {
                         return result_type( End, End );
@@ -468,11 +471,11 @@ namespace boost {
                         if( m_eCompress==token_compress_on )
                         {
                             // Find first non-matching character
-                            while( m_Pred(*It2) && It2!=End ) ++It2;
+                            while( It2!=End && m_Pred(*It2) ) ++It2;
                         }
                         else
                         {
-                            // Advance by one possition                         
+                            // Advance by one possition
                             ++It2;
                         }
 
@@ -499,21 +502,27 @@ namespace boost {
                 typedef iterator_range<input_iterator_type> result_type;
 
                 // Construction
-                range_finderF( 
-                    input_iterator_type Begin, 
+                range_finderF(
+                    input_iterator_type Begin,
                     input_iterator_type End ) : m_Range(Begin, End) {}
 
-                range_finderF(const iterator_range<input_iterator_type>& Range) : 
+                range_finderF(const iterator_range<input_iterator_type>& Range) :
                     m_Range(Range) {}
 
                 // Operation
                 template< typename ForwardIterator2T >
-                iterator_range<ForwardIterator2T> 
-                operator()( 
-                    ForwardIterator2T, 
+                iterator_range<ForwardIterator2T>
+                operator()(
+                    ForwardIterator2T,
                     ForwardIterator2T ) const
                 {
+#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) 
+                    return iterator_range<const ForwardIterator2T>(this->m_Range);
+#elif BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+                    return iterator_range<ForwardIterator2T>(m_Range.begin(), m_Range.end());
+#else
                     return m_Range;
+#endif
                 }
 
             private:

include/boost/algorithm/string/detail/finder_regex.hpp

@@ -12,8 +12,10 @@
 
 #include <boost/algorithm/string/config.hpp>
 #include <boost/regex.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
 
 namespace boost {
     namespace algorithm {
@@ -29,7 +31,6 @@ namespace boost {
                 typedef regex_search_result<IteratorT> type;
                 typedef iterator_range<IteratorT> base_type;
                 typedef BOOST_STRING_TYPENAME base_type::value_type value_type;
-                typedef BOOST_STRING_TYPENAME base_type::reference reference;
                 typedef BOOST_STRING_TYPENAME base_type::difference_type difference_type;
                 typedef BOOST_STRING_TYPENAME base_type::const_iterator const_iterator;
                 typedef BOOST_STRING_TYPENAME base_type::iterator iterator;

include/boost/algorithm/string/detail/formatter.hpp

@@ -10,8 +10,12 @@
 #ifndef BOOST_STRING_FORMATTER_DETAIL_HPP
 #define BOOST_STRING_FORMATTER_DETAIL_HPP
 
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/const_iterator.hpp>
+
 #include <boost/algorithm/string/detail/util.hpp>
 
 //  generic replace functors -----------------------------------------------//
@@ -23,22 +27,30 @@ namespace boost {
 //  const format functor ----------------------------------------------------//
 
             // constant format functor
-            template<typename CollectionT>
+            template<typename RangeT>
             struct const_formatF
             {
             private:
                 typedef BOOST_STRING_TYPENAME
-                    const_iterator_of<CollectionT>::type format_iterator;
+                    range_const_iterator<RangeT>::type format_iterator;
                 typedef iterator_range<format_iterator> result_type;
             
             public:
                 // Construction
-                const_formatF(const CollectionT& Format) :
+                const_formatF(const RangeT& Format) :
                     m_Format(begin(Format), end(Format)) {}
 
                 // Operation
-                template<typename Collection2T>
-                const result_type& operator()(const Collection2T&) const
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+                template<typename Range2T>
+                result_type& operator()(const Range2T&)
+                {
+                    return m_Format;
+                }
+#endif
+
+                template<typename Range2T>
+                const result_type& operator()(const Range2T&) const
                 {
                     return m_Format;
                 }
@@ -50,14 +62,14 @@ namespace boost {
 //  identity format functor ----------------------------------------------------//
 
             // identity format functor
-            template<typename CollectionT>
+            template<typename RangeT>
             struct identity_formatF
             {
                 // Operation
-                template< typename Collection2T >
-                const CollectionT& operator()(const Collection2T& Replace) const
+                template< typename Range2T >
+                const RangeT& operator()(const Range2T& Replace) const
                 {
-                    return CollectionT(begin(Replace), end(Replace));
+                    return RangeT(begin(Replace), end(Replace));
                 }
             };
 

include/boost/algorithm/string/detail/replace_storage.hpp

@@ -13,9 +13,7 @@
 #include <boost/algorithm/string/config.hpp>
 #include <algorithm>
 #include <boost/mpl/bool.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
 #include <boost/algorithm/string/sequence_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
 #include <boost/algorithm/string/detail/sequence.hpp>
 
 namespace boost {
@@ -123,6 +121,7 @@ namespace boost {
                     ForwardIteratorT InsertIt,
                     ForwardIteratorT SegmentBegin,
                     ForwardIteratorT SegmentEnd )
+
                 {
                     // Call replace to do the job
                     replace( Input, InsertIt, SegmentBegin, Storage );

include/boost/algorithm/string/detail/sequence.hpp

@@ -13,7 +13,9 @@
 #include <boost/algorithm/string/config.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/logical.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
 #include <boost/algorithm/string/sequence_traits.hpp>
 
 namespace boost {
@@ -110,7 +112,14 @@ namespace boost {
                     BOOST_STRING_TYPENAME InputT::iterator At=Input.erase( From, To );
                     if ( Begin!=End )
                     {
-                        Input.insert( At, Begin, End );
+                        if(!Input.empty())
+                        {
+                            Input.insert( At, Begin, End );
+                        }
+                        else
+                        {
+                            Input.insert( Input.begin(), Begin, End );
+                        }
                     }
                 }
             };
@@ -172,7 +181,14 @@ namespace boost {
                 BOOST_STRING_TYPENAME InputT::iterator To,
                 const InsertT& Insert )
             {
-                replace( Input, From, To, begin(Insert), end(Insert) );
+                if(From!=To)
+                {
+                    replace( Input, From, To, begin(Insert), end(Insert) );
+                }
+                else
+                {
+                    insert( Input, From, begin(Insert), end(Insert) );
+                }
             }
 
         } // namespace detail

include/boost/algorithm/string/detail/util.hpp

@@ -12,6 +12,7 @@
 
 #include <boost/algorithm/string/config.hpp>
 #include <functional>
+#include <boost/range/iterator_range.hpp>
 
 namespace boost {
     namespace algorithm {
@@ -22,7 +23,7 @@ namespace boost {
             //  empty_container 
             /*
                 This class represents always empty container,
-                containing elemets of type CharT.
+                containing elements of type CharT.
 
                 It is supposed to be used in a const version only
             */
@@ -92,7 +93,7 @@ namespace boost {
             {
                 SeqT operator()( const iterator_range<IteratorT>& Range ) const
                 {
-                    return copy_iterator_range<SeqT>(Range);
+                    return copy_range<SeqT>(Range);
                 }
             };
 

include/boost/algorithm/string/erase.hpp

@@ -11,15 +11,20 @@
 #define BOOST_STRING_ERASE_HPP
 
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+
 #include <boost/algorithm/string/find_format.hpp>
 #include <boost/algorithm/string/finder.hpp>
 #include <boost/algorithm/string/formatter.hpp>
 
 /*! \file
     Defines various erase algorithms. Each algorithm removes
-    a part(s) of the input according to a searching criterium.
+    part(s) of the input according to a searching criteria.
 */
 
 namespace boost {
@@ -29,21 +34,24 @@ namespace boost {
 
         //! Erase range algorithm
         /*!
-            Remove the given range from the input sequence.
-            The result is copied to the given output iterator.
-
-            \param Output A output iterator to which the result will be copied
+            Remove the given range from the input. The result is a modified copy of 
+            the input. It is returned as a sequence or copied to the output iterator.
+    
+            \param Output An output iterator to which the result will be copied
             \param Input An input sequence
-            \param SearchRange A range in the input to be substituted
-            \return An output iterator pointing just after last inserted character
+            \param SearchRange A range in the input to be removed
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT>
+        template<typename OutputIteratorT, typename RangeT>
         inline OutputIteratorT erase_range_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const iterator_range<
                 BOOST_STRING_TYPENAME 
-                    const_iterator_of<CollectionT>::type>& SearchRange )
+                    range_const_iterator<RangeT>::type>& SearchRange )
         {
             return find_format_copy(
                 Output,
@@ -54,19 +62,14 @@ namespace boost {
 
         //! Erase range algorithm
         /*!
-            Remove the given range from the input sequence.
-            The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param SearchRange A range in the input to be substituted
-            \return A modified copy of the input
+            \overload
         */
         template<typename SequenceT>
         inline SequenceT erase_range_copy( 
             const SequenceT& Input,
             const iterator_range<
                 BOOST_STRING_TYPENAME 
-                    const_iterator_of<SequenceT>::type>& SearchRange )
+                    range_const_iterator<SequenceT>::type>& SearchRange )
         {
             return find_format_copy( 
                 Input,
@@ -76,18 +79,18 @@ namespace boost {
 
         //! Erase range algorithm
         /*!
-            Remove the given range from the input sequence.
+            Remove the given range from the input.
             The input sequence is modified in-place.
 
             \param Input An input sequence
-            \param SearchRange A range in the input to be substituted
+            \param SearchRange A range in the input to be removed
         */
         template<typename SequenceT>
         inline void erase_range( 
             SequenceT& Input,
             const iterator_range<
                 BOOST_STRING_TYPENAME 
-                    iterator_of<SequenceT>::type>& SearchRange )
+                    range_iterator<SequenceT>::type>& SearchRange )
         {
             find_format( 
                 Input, 
@@ -99,22 +102,26 @@ namespace boost {
 
         //! Erase first algorithm
         /*!
-            Remove the first match of the search sequence from the input.
-            The result is copied to the given output iterator.
+            Remove the first occurrence of the substring from the input.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
 
-H            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \return An output iterator pointing just after last inserted character
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for 
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+            
+            \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT erase_first_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search )
+            const Range1T& Input,
+            const Range2T& Search )
         {
             return find_format_copy(
                 Output,
@@ -125,17 +132,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase first algorithm
         /*!
-            Remove the first match of the search sequence from the input. 
-            The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \return A modified copy of the input
+            \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT erase_first_copy( 
             const SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             return find_format_copy( 
                 Input, 
@@ -145,16 +147,16 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase first algorithm
         /*!
-            Remove the first match of the search sequence from the input. 
+            Remove the first occurrence of the substring from the input. 
             The input sequence is modified in-place.
 
-            \param Input An input sequence
-            \param Search A string to be searched for. 
+            \param Input An input string
+            \param Search A substring to be searched for. 
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void erase_first( 
             SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             find_format( 
                 Input, 
@@ -166,23 +168,28 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase first algorithm ( case insensitive )
         /*!
-            Remove the first match of the search sequence from the input. 
-            The result is copied to the given output iterator. Searching is case insensitive.
+            Remove the first occurrence of the substring from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+            Searching is case insensitive.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \param Loc a locale used for case insensitive comparison
-            \return An output iterator pointing just after last inserted character
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for 
+            \param Loc A locale used for case insensitive comparison
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT ierase_first_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy(
@@ -194,18 +201,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase first algorithm ( case insensitive )
         /*!
-            Remove the first match of the search sequence from the input. 
-            The result is a modified copy of the input. Searching is case insensitive.
-
-            \param Input An input sequence
-            \param Search A string to be searched for.
-            \param Loc a locale used for case insensitive comparison
-            \return A modified copy of the input
+            \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT ierase_first_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy( 
@@ -216,17 +217,17 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase first algorithm ( case insensitive )
         /*!
-            Remove the first match of the search sequence from the input. 
+            Remove the first occurrence of the substring from the input. 
             The input sequence is modified in-place. Searching is case insensitive.
 
-            \param Input An input sequence
-            \param Search A string to be searched for.
-            \param Loc a locale used for case insensitive comparison
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void ierase_first( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             find_format( 
@@ -239,22 +240,26 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase last algorithm
         /*!
-            Remove the last match of the search sequence from the input. 
-            The result is copied to the given output iterator.
+            Remove the last occurrence of the substring from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \return An output iterator pointing just after last inserted character
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for.
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT erase_last_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search )
+            const Range1T& Input,
+            const Range2T& Search )
         {
             return find_format_copy(
                 Output,
@@ -265,17 +270,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase last algorithm
         /*!
-            Remove the last match of the search sequence from the input. 
-            The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \return A modified copy of the input
+            \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT erase_last_copy( 
             const SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             return find_format_copy( 
                 Input, 
@@ -285,16 +285,16 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase last algorithm
         /*!
-            Remove the last match of the search sequence from the input. 
+            Remove the last occurrence of the substring from the input. 
             The input sequence is modified in-place.
 
-            \param Input An input sequence
-            \param Search A string to be searched for. 
+            \param Input An input string
+            \param Search A substring to be searched for 
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void erase_last( 
             SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             find_format( 
                 Input, 
@@ -306,23 +306,28 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase last algorithm ( case insensitive )
         /*!
-            Remove the last match of the search sequence from the input. 
-            The result is copied to the given output iterator. Searching is case insensitive.
+            Remove the last occurrence of the substring from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+            Searching is case insensitive.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \param Loc a locale used for case insensitive comparison
-            \return An output iterator pointing just after last inserted character
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Loc A locale used for case insensitive comparison
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT ierase_last_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy(
@@ -334,18 +339,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase last algorithm ( case insensitive )
         /*!
-            Remove the last match of the search sequence from the input. 
-            The result is a modified copy of the input. Searching is case insensitive.
-
-            \param Input An input sequence
-            \param Search A string to be searched for.
-            \param Loc a locale used for case insensitive comparison
-            \return A modified copy of the input
+            \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT ierase_last_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy( 
@@ -356,17 +355,17 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase last algorithm ( case insensitive )
         /*!
-            Remove the last match of the search sequence from the input. 
+            Remove the last occurrence of the substring from the input. 
             The input sequence is modified in-place. Searching is case insensitive.
 
-            \param Input An input sequence
-            \param Search A string to be searched for.
-            \param Loc a locale used for case insensitive comparison
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void ierase_last( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             find_format( 
@@ -379,23 +378,28 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase nth algorithm
         /*!
-            Remove the Nth match of the search sequence in the input.
-            The result is copied to the given output iterator.
+            Remove the Nth occurrence of the substring in the input.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+            
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param Search A string to be searched for. 
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for
             \param Nth An index of the match to be replaced. The index is 0-based.
-            \return An output iterator pointing just after last inserted character
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT erase_nth_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             unsigned int Nth )
         {
             return find_format_copy(
@@ -407,18 +411,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase nth algorithm
         /*!
-            Remove the Nth match of the search sequence in the input.
-            The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \param Nth An index of the match to be replaced. The index is 0-based.
-            \return A modified copy of the input
+            \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT erase_nth_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             unsigned int Nth )
         {
             return find_format_copy( 
@@ -429,17 +427,17 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase nth algorithm
         /*!
-            Remove the Nth match of the search sequence in the input.
+            Remove the Nth occurrence of the substring in the input.
             The input sequence is modified in-place.
 
-            \param Input An input sequence
-            \param Search A string to be searched for. 
+            \param Input An input string
+            \param Search A substring to be searched for. 
             \param Nth An index of the match to be replaced. The index is 0-based.
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void erase_nth( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             unsigned int Nth )
         {
             find_format( 
@@ -452,24 +450,29 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase nth algorithm ( case insensitive )
         /*!
-            Remove the Nth match of the search sequence in the input.
-            The result is copied to the given output iterator. Searching is case insensitive.
+            Remove the Nth occurrence of the substring in the input.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator. 
+            Searching is case insensitive.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param Search A string to be searched for. 
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for.
             \param Nth An index of the match to be replaced. The index is 0-based.
-            \param Loc a locale used for case insensitive comparison
-            \return An output iterator pointing just after last inserted character
+            \param Loc A locale used for case insensitive comparison
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT ierase_nth_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
@@ -482,19 +485,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase nth algorithm
         /*!
-            Remove the Nth match of the search sequence in the input.
-            The result is a modified copy of the input. Searching is case insensitive.
-
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \param Nth An index of the match to be replaced. The index is 0-based.
-            \param Loc a locale used for case insensitive comparison
-            \return A modified copy of the input
+            \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT ierase_nth_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
@@ -506,18 +502,18 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase nth algorithm
         /*!
-            Remove the Nth match of the search sequence in the input.
+            Remove the Nth occurrence of the substring in the input.
             The input sequence is modified in-place. Searching is case insensitive.
 
-            \param Input An input sequence
-            \param Search A string to be searched for. 
+            \param Input An input string
+            \param Search A substring to be searched for. 
             \param Nth An index of the match to be replaced. The index is 0-based.
-            \param Loc a locale used for case insensitive comparison
+            \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void ierase_nth( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
@@ -532,22 +528,27 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase all algorithm
         /*!
-            Remove all the occurrences of the search sequence from the input. 
-            The result is copied to the given output iterator.
+            Remove all the occurrences of the string from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+                        
 
-            \param Output A output iterator to which the result will be copied
+            \param Output An output iterator to which the result will be copied
             \param Input An input sequence
-            \param Search A string to be searched for. 
-            \return An output iterator pointing just after last inserted character
+            \param Search A substring to be searched for. 
+            \return An output iterator pointing just after the last inserted character or
+                    a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT erase_all_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search )
+            const Range1T& Input,
+            const Range2T& Search )
         {
             return find_format_all_copy(
                 Output,
@@ -558,17 +559,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase all algorithm
         /*!
-            Remove all the occurrences of the search sequence from the input. 
-            The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \return A modified copy of the input
+            \overload
         */  
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT erase_all_copy( 
             const SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             return find_format_all_copy( 
                 Input, 
@@ -578,16 +574,16 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase all algorithm
         /*!
-            Remove all the occurrences of the search sequence from the input. 
+            Remove all the occurrences of the string from the input. 
             The input sequence is modified in-place.
 
-            \param Input An input sequence
-            \param Search A string to be searched for. 
+            \param Input An input string
+            \param Search A substring to be searched for. 
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void erase_all( 
             SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             find_format_all( 
                 Input, 
@@ -599,23 +595,28 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase all algorithm ( case insensitive )
         /*!
-            Remove all the occurrences of the search sequence from the input. 
-            The result is copied to the given output iterator. Searching is case insensitive.
+            Remove all the occurrences of the string from the input. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator. 
+            Searching is case insensitive.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \param Loc a locale used for case insensitive comparison
-            \return An output iterator pointing just after last inserted character
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param Search A substring to be searched for
+            \param Loc A locale used for case insensitive comparison
+            \return An output iterator pointing just after the last inserted character or
+                    a modified copy of the input
+
+              \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT ierase_all_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_all_copy(
@@ -627,18 +628,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase all algorithm ( case insensitive )
         /*!
-            Remove all the occurrences of the search sequence from the input. 
-            The result is a modified copy of the input. Searching is case insensitive.
-
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \param Loc a locale used for case insensitive comparison
-            \return A modified copy of the input
+            \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT ierase_all_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_all_copy( 
@@ -649,17 +644,17 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase all algorithm ( case insensitive )
         /*!
-            Remove all the occurrences of the search sequence from the input. 
+            Remove all the occurrences of the string from the input. 
             The input sequence is modified in-place. Searching is case insensitive.
 
-            \param Input An input sequence
-            \param Search A string to be searched for. 
-            \param Loc a locale used for case insensitive comparison
+            \param Input An input string
+            \param Search A substring to be searched for. 
+            \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void ierase_all( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             find_format_all( 
@@ -672,21 +667,26 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase head algorithm
         /*!
-            Remove the head from the input. Head is a prefix of a seqence of given size. 
-            If the sequence is shorter then required, whole sequence if 
-            considered to be the head. The result is copied to the given output iterator.
+            Remove the head from the input. The head is a prefix of a sequence of given size. 
+            If the sequence is shorter then required, the whole string is 
+            considered to be the head. The result is a modified copy of the input. 
+            It is returned as a sequence or copied to the output iterator.
+            
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param N A length of the head
-            \return An output iterator pointing just after last inserted character
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param N Length of the head
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename CollectionT>
+            typename RangeT>
         inline OutputIteratorT erase_head_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             unsigned int N )
         {
             return find_format_copy(
@@ -698,13 +698,7 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase head algorithm
         /*!
-            Remove the head from the input. Head is a prefix of a seqence of given size. 
-            If the sequence is shorter then required, whole sequence if 
-            considered to be the head. The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param N A length of the head
-            \return A modified copy of the input
+            \overload
         */
         template<typename SequenceT>
         inline SequenceT erase_head_copy( 
@@ -719,12 +713,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase head algorithm
         /*!
-            Remove the head from the input. Head is a prefix of a seqence of given size. 
-            If the sequence is shorter then required, whole sequence if 
+            Remove the head from the input. The head is a prefix of a sequence of given size. 
+            If the sequence is shorter then required, the whole string is 
             considered to be the head. The input sequence is modified in-place.
 
-            \param Input An input sequence
-            \param N A length of the head
+            \param Input An input string
+            \param N Length of the head
         */
         template<typename SequenceT>
         inline void erase_head( 
@@ -741,21 +735,26 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase tail algorithm
         /*!
-            Remove the tail from the input. Tail is a suffix of a seqence of given size. 
-            If the sequence is shorter then required, whole sequence if 
-            considered to be the tail. The result is copied to the given output iterator.
+            Remove the tail from the input. The tail is a suffix of a sequence of given size. 
+            If the sequence is shorter then required, the whole string is 
+            considered to be the tail. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
-            \param N A length of the head
-            \return An output iterator pointing just after last inserted character
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
+            \param N Length of the head
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+            
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
         template<
             typename OutputIteratorT,
-            typename CollectionT>
+            typename RangeT>
         inline OutputIteratorT erase_tail_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             unsigned int N )
         {
             return find_format_copy(
@@ -767,13 +766,7 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase tail algorithm
         /*!
-            Remove the tail from the input. Tail is a suffix of a seqence of given size. 
-            If the sequence is shorter then required, whole sequence is 
-            considered to be the tail. The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param N A length of the head
-            \return A modified copy of the input
+            \overload
         */
         template<typename SequenceT>
         inline SequenceT erase_tail_copy( 
@@ -788,12 +781,12 @@ H            \param Output A output iterator to which the result will be copied
 
         //! Erase tail algorithm
         /*!
-            Remove the tail from the input. Tail is a suffix of a seqence of given size. 
-            If the sequence is shorter then required, whole sequence is
+            Remove the tail from the input. The tail is a suffix of a sequence of given size. 
+            If the sequence is shorter then required, the whole string is
             considered to be the tail. The input sequence is modified in-place.
 
-            \param Input An input sequence
-            \param N A length of the head
+            \param Input An input string
+            \param N Length of the head
         */
         template<typename SequenceT>
         inline void erase_tail( 

include/boost/algorithm/string/find.hpp

@@ -11,15 +11,21 @@
 #define BOOST_STRING_FIND_HPP
 
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/result_iterator.hpp>
+
 #include <boost/algorithm/string/finder.hpp>
 #include <boost/algorithm/string/compare.hpp>
 #include <boost/algorithm/string/constants.hpp>
 
 /*! \file
     Defines a set of find algorithms. The algorithms are searching
-    for a subsequence of the input. The result is given as an \c iterator_range
+    for a substring of the input. The result is given as an \c iterator_range
     delimiting the substring.
 */
 
@@ -32,19 +38,19 @@ namespace boost {
         /*!
             Search the input using the given finder.
 
-            \param Input A collection which will be searched.
+            \param Input A string which will be searched.
             \param Finder Finder object used for searching.
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c CollectionT::iterator or 
-                \c CollectionT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
         */
-        template<typename CollectionT, typename FinderT>
+        template<typename RangeT, typename FinderT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find( 
-            CollectionT& Input, 
+            RangeT& Input, 
             FinderT Finder)
         {
             return Finder(begin(Input),end(Input));
@@ -54,23 +60,24 @@ namespace boost {
 
         //! Find first algorithm
         /*!
-            Search for a first match of search sequence in the 
-            input collection. 
+            Search for the first occurence of the substring in the input. 
             
-            \param Input A container which will be searched.
-            \param Search A string to be searched for.
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c CollectionT::iterator or 
-                \c CollectionT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
+
+              \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_first( 
-            Collection1T& Input, 
-            const Collection2T& Search)
+            Range1T& Input, 
+            const Range2T& Search)
         {
             return first_finder(Search)(
                 begin(Input),end(Input));
@@ -78,24 +85,26 @@ namespace boost {
 
         //! Find first algorithm ( case insensitive )
         /*!
-            Search for a first match of search sequence in the 
-            input collection. Searching is case insensitive.
+            Search for the first occurence of the substring in the input. 
+            Searching is case insensitive.
             
-            \param Input A container which will be searched.
-            \param Search A string to be searched for.
-            \param Loc a locale used for case insensitive comparison
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Loc A locale used for case insensitive comparison
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_first( 
-            Collection1T& Input, 
-            const Collection2T& Search,
+            Range1T& Input, 
+            const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
             return first_finder(Search,is_iequal(Loc))(
@@ -106,23 +115,24 @@ namespace boost {
 
         //! Find last algorithm
         /*!
-            Search for a last match of search sequence in the 
-            input collection. 
+            Search for the last occurence of the substring in the input. 
             
-            \param Input A container which will be searched.
-            \param Search A string to be searched for.
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_last( 
-            Collection1T& Input, 
-            const Collection2T& Search)
+            Range1T& Input, 
+            const Range2T& Search)
         {
             return last_finder(Search)(
                 begin(Input),end(Input));
@@ -130,24 +140,26 @@ namespace boost {
 
         //! Find last algorithm ( case insensitive )
         /*!
-            Search for a last match of search sequence in the 
-            input collection. Searching is case insensitive.
+            Search for the last match a string in the input. 
+            Searching is case insensitive.
             
-            \param Input A container which will be searched.
-            \param Search A string to be searched for.
-            \param Loc a locale used for case insensitive comparison
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Loc A locale used for case insensitive comparison
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
+        
+            \note This function provides the strong exception-safety guarantee    
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_last( 
-            Collection1T& Input, 
-            const Collection2T& Search,
+            Range1T& Input, 
+            const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
             return last_finder(Search, is_iequal(Loc))(
@@ -158,24 +170,24 @@ namespace boost {
 
         //! Find n-th algorithm 
         /*!
-            Search for an n-th match of search sequence in the 
-            input collection.         
+            Search for the n-th (zero-indexed) occurence of the substring in the 
+            input.         
             
-            \param Input A container which will be searched.
-            \param Search A string to be searched for.
-            \param Nth An index of the match to be found.
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Nth An index (zero-indexed) of the match to be found.
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_nth( 
-            Collection1T& Input, 
-            const Collection2T& Search,
+            Range1T& Input, 
+            const Range2T& Search,
             unsigned int Nth)
         {
             return nth_finder(Search,Nth)(
@@ -184,25 +196,28 @@ namespace boost {
 
         //! Find n-th algorithm ( case insensitive ).
         /*!
-            Search for an n-th match of search sequence in the 
-            input collection. Searching is case insensitive.
+            Search for the n-th (zero-indexed) occurence of the substring in the 
+            input. Searching is case insensitive.
             
-            \param Input A container which will be searched.
-            \param Search A string to be searched for.
-            \param Nth An index of the match to be found.
-            \param Loc a locale used for case insensitive comparison
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Nth An index (zero-indexed) of the match to be found.
+            \param Loc A locale used for case insensitive comparison
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
+
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_nth( 
-            Collection1T& Input, 
-            const Collection2T& Search,
+            Range1T& Input, 
+            const Range2T& Search,
             unsigned int Nth,
             const std::locale& Loc=std::locale())
         {
@@ -214,23 +229,25 @@ namespace boost {
 
         //! Find head algorithm
         /*!
-            Get the head of the input. Head is a prefix of 
-            a seqence of given size. If the sequence is shorter then required,
-            whole sequence if considered to be the head.
+            Get the head of the input. Head is a prefix of the string of the 
+            given size. If the input is shorter then required, whole input if considered 
+            to be the head.
 
-            \param Input A container which will be searched.
-            \param N A length of the head
+            \param Input An input string
+            \param N Length of the head
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename CollectionT>
+        template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_head( 
-            CollectionT& Input, 
+            RangeT& Input, 
             unsigned int N)
         {
             return head_finder(N)(
@@ -241,23 +258,26 @@ namespace boost {
 
         //! Find tail algorithm
         /*!
-            Get the tail of the input. Head is a suffix of 
-            a seqence of given size. If the sequence is shorter then required,
-            whole sequence if considered to be the tail.
+            Get the head of the input. Head is a suffix of the string of the 
+            given size. If the input is shorter then required, whole input if considered 
+            to be the tail.
 
-            \param Input A container which will be searched.
-            \param N A length of the tail
+            \param Input An input string
+            \param N Length of the tail
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c CollectionT::iterator or 
-                \c CollectionT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
+
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename CollectionT>
+        template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_tail( 
-            CollectionT& Input, 
+            RangeT& Input, 
             unsigned int N)
         {
             return tail_finder(N)(
@@ -268,23 +288,26 @@ namespace boost {
 
         //! Find token algorithm
         /*!
-            Look for a given token in the collection. Token is specified by a predicate.
-            If bCompressed is given, adjacent tokens are considered to be one match.
+            Look for a given token in the string. Token is a character that matches the
+            given predicate.
+            If the "token compress mode" is enabled, adjacent tokens are considered to be one match.
             
-            \param Input A container which will be searched.
+            \param Input A input string.
             \param Pred An unary predicate to identify a token
             \param eCompress Enable/Disable compressing of adjacent tokens
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c CollectionT::iterator or 
-                \c CollectionT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
+        
+            \note This function provides the strong exception-safety guarantee    
         */
-        template<typename CollectionT, typename PredicateT>
+        template<typename RangeT, typename PredicateT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_token( 
-            CollectionT& Input,
+            RangeT& Input,
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off)
         {

include/boost/algorithm/string/find_format.hpp

@@ -12,15 +12,18 @@
 
 #include <deque>
 #include <boost/detail/iterator.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/const_iterator.hpp>
+
 #include <boost/algorithm/string/concept.hpp>
 #include <boost/algorithm/string/detail/find_format.hpp>
 #include <boost/algorithm/string/detail/find_format_all.hpp>
 
 /*! \file
     Defines generic replace algorithms. Each algorithm replaces
-    a part(s) of the input. The part to be replaced is looked up using a Finder object.
+    part(s) of the input. The part to be replaced is looked up using a Finder object.
     Result of finding is then used by a Formatter object to generate the replacement.
 */
 
@@ -33,33 +36,37 @@ namespace boost {
         /*!
             Use the Finder to search for a substring. Use the Formatter to format
             this substring and replace it in the input.
-            The resulting sequence is copied to the given output iterator.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
     
-            \param Output A output iterator to which the result will be copied
+            \param Output An output iterator to which the result will be copied
             \param Input An input sequence
             \param Finder A Finder object used to search for a match to be replaced
             \param Formatter A Formatter object used to format a match
-            \return An output iterator pointing just after last inserted character
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+            \note The second variant of this function provides the strong exception-safety guarantee
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT,
+            typename RangeT,
             typename FinderT,
             typename FormatterT>
         inline OutputIteratorT find_format_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             FinderT Finder,
             FormatterT Formatter )
         {
             // Concept check
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME const_iterator_of<CollectionT>::type> >();
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
             function_requires< 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME const_iterator_of<CollectionT>::type> >();
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
 
             return detail::find_format_copy_impl(
                 Output,
@@ -71,14 +78,7 @@ namespace boost {
 
         //! Generic replace algorithm
         /*!
-            Use the Finder to search for a substring. Use the Formatter to format
-            this substring and replace it in the input.
-            The result is the modified copy of the input.
-
-            \param Input An input sequence
-            \param Finder A Finder object used to search for a match to be replaced
-            \param Formatter A Formatter object used to format a match
-            \return A modified copy of the input 
+            \overload
         */
         template< 
             typename SequenceT, 
@@ -92,11 +92,11 @@ namespace boost {
             // Concept check
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME const_iterator_of<SequenceT>::type> >();
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
             function_requires< 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME const_iterator_of<SequenceT>::type> >();
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
 
             return detail::find_format_copy_impl(
                 Input,
@@ -126,11 +126,11 @@ namespace boost {
             // Concept check
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME const_iterator_of<SequenceT>::type> >();
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
             function_requires< 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME const_iterator_of<SequenceT>::type> >();
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
 
             detail::find_format_impl(
                 Input,
@@ -147,33 +147,37 @@ namespace boost {
             Use the Finder to search for a substring. Use the Formatter to format
             this substring and replace it in the input. Repeat this for all matching
             substrings.
-            The resulting sequence is copied to the given output iterator.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
 
-            \param Output A output iterator to which the result will be copied
+            \param Output An output iterator to which the result will be copied
             \param Input An input sequence
             \param Finder A Finder object used to search for a match to be replaced
             \param Formatter A Formatter object used to format a match
-            \return An output iterator pointing just after last inserted character
+            \return An output iterator pointing just after the last inserted character or
+                a modified copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT,
+            typename RangeT,
             typename FinderT,
             typename FormatterT>
         inline OutputIteratorT find_format_all_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             FinderT Finder,
             FormatterT Formatter)
         {
             // Concept check
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME const_iterator_of<CollectionT>::type> >();
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
             function_requires< 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME const_iterator_of<CollectionT>::type> >();
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
 
             return detail::find_format_all_copy_impl(
                 Output,
@@ -185,15 +189,7 @@ namespace boost {
 
         //! Generic replace all algorithm
         /*!
-            Use the Finder to search for a substring. Use the Formatter to format
-            this substring and replace it in the input. Repeat this for all matching
-            substrings.
-            The result is the modified copy of the input.
-
-            \param Input An input sequence
-            \param Finder A Finder object used to search for a match to be replaced
-            \param Formatter A Formatter object used to format a match
-            \return A modified copy of the input 
+            \overload
         */
         template< 
             typename SequenceT, 
@@ -207,11 +203,11 @@ namespace boost {
             // Concept check
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME const_iterator_of<SequenceT>::type> >();
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
             function_requires< 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME const_iterator_of<SequenceT>::type> >();
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
 
             return detail::find_format_all_copy_impl(
                 Input,
@@ -242,11 +238,11 @@ namespace boost {
             // Concept check
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME const_iterator_of<SequenceT>::type> >();
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
             function_requires< 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME const_iterator_of<SequenceT>::type> >();
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
 
             detail::find_format_all_impl(
                 Input,

include/boost/algorithm/string/find_iterator.hpp

@@ -1,23 +1,32 @@
 //  Boost string_algo library find_iterator.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
+//  Copyright Pavol Droba 2002-2004. Use, modification and
 //  distribution is subject to 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 for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_ITERATOR_HPP
 #define BOOST_STRING_FIND_ITERATOR_HPP
 
-
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
-#include <boost/algorithm/string/detail/find_iterator.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/result_iterator.hpp>
+
+#include <boost/algorithm/string/detail/find_iterator.hpp>
+
+/*! \file
+    Defines find iterator classes. Find iterator repeatly applies a Finder
+    to the specified input string to search for matches. Dereferencing
+    the iterator yields the current match or a range between the last and the current
+    match depending on the iterator used.
+*/
+
 namespace boost {
     namespace algorithm { 
 
@@ -26,10 +35,10 @@ namespace boost {
         //! find_iterator
         /*!    
             Find iterator encapsulates a Finder and allows
-            an incremental searching in the sequence.
+            for incremental searching in a string.
             Each increment moves the iterator to the next match.
 
-            Find iterator is readable forward traversal iterator.
+            Find iterator is a readable forward traversal iterator.
 
             Dereferencing the iterator yields an iterator_range delimiting
             the current match.
@@ -96,6 +105,22 @@ namespace boost {
                 increment();
             }
 
+            //! Constructor
+            /*!
+                Construct new find_iterator for a given finder
+                and a range.
+            */
+            template<typename FinderT, typename RangeT>
+            find_iterator(
+                    RangeT& Col,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_Match(begin(Col),begin(Col)),
+                m_End(end(Col))
+            {
+                increment();
+            }
+
         private:
         // iterator operations
 
@@ -114,14 +139,13 @@ namespace boost {
             // comparison
             bool equal( const find_iterator& Other ) const
             {
-                return 
+                bool bEof=eof();
+                bool bOtherEof=Other.eof();
+
+                return bEof || bOtherEof ? bEof==bOtherEof :
                     (
                         m_Match==Other.m_Match &&
                         m_End==Other.m_End 
-                    ) 
-                    ||
-                    ( 
-                        eof() && Other.eof() 
                     );
             }
 
@@ -130,7 +154,7 @@ namespace boost {
 
             //! Eof check
             /*!
-                Check the eof condition. Eof condition means, that
+                Check the eof condition. Eof condition means that
                 there is nothing more to be searched i.e. find_iterator
                 is after the last match.
             */
@@ -152,17 +176,17 @@ namespace boost {
 
         //! find iterator construction helper
         /*!
-         *    Construct a find iterator to iterate through the specified collection
+         *    Construct a find iterator to iterate through the specified string
          */
-         template<typename CollectionT, typename FinderT>
+        template<typename RangeT, typename FinderT>
         inline find_iterator< 
-            BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         make_find_iterator(
-            CollectionT& Collection,
+            RangeT& Collection,
             FinderT Finder)
         {
-            return find_iterator<BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type>(
-                Collection.begin(), Collection.end(), Finder);
+            return find_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
+                begin(Collection), end(Collection), Finder);
         }
 
 //  split iterator -----------------------------------------------//
@@ -170,11 +194,11 @@ namespace boost {
         //! split_iterator
         /*!    
             Split iterator encapsulates a Finder and allows
-            an incremental searching in the sequence.
+            for incremental searching in a string.
             Unlike the find iterator, split iterator iterates
-            through gasps between matches.
+            through gaps between matches.
 
-            Find iterator is readable forward traversal iterator.
+            Find iterator is a readable forward traversal iterator.
 
             Dereferencing the iterator yields an iterator_range delimiting
             the current match.
@@ -216,17 +240,19 @@ namespace boost {
             split_iterator() {}
             //! Copy constructor
             /*!
-                Construct a copy of the find_iterator
+                Construct a copy of the split_iterator
             */
             split_iterator( const split_iterator& Other ) :
                 base_type(Other),
                 m_Match(Other.m_Match),
                 m_Next(Other.m_Next),
-                m_End(Other.m_End) {}
+                m_End(Other.m_End),
+                m_bEof(false)
+            {}
 
             //! Constructor
             /*!
-                Construct new find_iterator for a given finder
+                Construct new split_iterator for a given finder
                 and a range.
             */
             template<typename FinderT>
@@ -237,10 +263,29 @@ namespace boost {
                 detail::find_iterator_base<IteratorT>(Finder,0),
                 m_Match(Begin,Begin),
                 m_Next(Begin),
-                m_End(End)
+                m_End(End),
+                m_bEof(false)
             {
                 increment();
             }
+            //! Constructor
+            /*!
+                Construct new split_iterator for a given finder
+                and a collection.
+            */
+            template<typename FinderT, typename RangeT>
+            split_iterator(
+                    RangeT& Col,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_Match(begin(Col),begin(Col)),
+                m_Next(begin(Col)),
+                m_End(end(Col)),
+                m_bEof(false)
+            {
+                increment();
+            }
+
 
         private:
         // iterator operations
@@ -255,6 +300,16 @@ namespace boost {
             void increment()
             {
                 match_type FindMatch=this->do_find( m_Next, m_End );
+
+                if(FindMatch.begin()==m_End && FindMatch.end()==m_End)
+                {
+                    if(m_Match.end()==m_End)
+                    {
+                        // Mark iterator as eof
+                        m_bEof=true;
+                    }
+                }
+
                 m_Match=match_type( m_Next, FindMatch.begin() );
                 m_Next=FindMatch.end();
             }
@@ -262,15 +317,14 @@ namespace boost {
             // comparison
             bool equal( const split_iterator& Other ) const
             {
-                return
+                bool bEof=eof();
+                bool bOtherEof=Other.eof();
+
+                return bEof || bOtherEof ? bEof==bOtherEof :
                     (
                         m_Match==Other.m_Match &&
                         m_Next==Other.m_Next &&
-                        m_End==Other.m_End 
-                    ) 
-                    ||
-                    ( 
-                        eof() && Other.eof() 
+                        m_End==Other.m_End
                     );
             }
 
@@ -279,18 +333,13 @@ namespace boost {
 
             //! Eof check
             /*!
-                Check the eof condition. Eof condition means, that
+                Check the eof condition. Eof condition means that
                 there is nothing more to be searched i.e. find_iterator
                 is after the last match.
             */
             bool eof() const
             {
-                return 
-                    this->is_null() || 
-                    ( 
-                        m_Match.begin() == m_End &&
-                        m_Match.end() == m_End
-                    );
+                return this->is_null() || m_bEof;
             }
 
         private:
@@ -298,21 +347,22 @@ namespace boost {
             match_type m_Match;
             input_iterator_type m_Next;
             input_iterator_type m_End;
+            bool m_bEof;
         };
 
         //! split iterator construction helper
         /*!
          *    Construct a split iterator to iterate through the specified collection
          */
-         template<typename CollectionT, typename FinderT>
+        template<typename RangeT, typename FinderT>
         inline split_iterator< 
-            BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         make_split_iterator(
-            CollectionT& Collection,
+            RangeT& Collection,
             FinderT Finder)
         {
-            return split_iterator<BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type>(
-                Collection.begin(), Collection.end(), Finder);
+            return split_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
+                begin(Collection), end(Collection), Finder);
         }
 
 

include/boost/algorithm/string/finder.hpp

@@ -11,16 +11,20 @@
 #define BOOST_STRING_FINDER_HPP
 
 #include <boost/algorithm/string/config.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+
 #include <boost/algorithm/string/constants.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
 #include <boost/algorithm/string/detail/finder.hpp>
 #include <boost/algorithm/string/compare.hpp>
 
 /*! \file
     Defines Finder generators. Finder object is a functor which is able to 
-    find a subsequence matching a specific criterium in an input
-    sequence. 
+    find a substring matching a specific criteria in the input.
     Finders are used as a pluggable components for replace, find 
     and split facilities. This header contains generator functions 
     for finders provided in this library.
@@ -34,40 +38,33 @@ namespace boost {
         //! "First" finder 
         /*!
             Construct the \c first_finder. The finder searches for the first
-            occurrence of the search sequence in a given input.
-            The result is given as a \c iterator_range delimiting the match.
+            occurrence of the string in a given input.
+            The result is given as an \c iterator_range delimiting the match.
 
-            \param Search A sequence to be searched for.
+            \param Search A substring to be searched for.
+            \param Comp An element comparison predicate
             \return An instance of the \c first_finder object
         */
         template<typename ContainerT>
         inline detail::first_finderF<
-            BOOST_STRING_TYPENAME const_iterator_of<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             is_equal>
         first_finder( const ContainerT& Search )
         {
             return 
                 detail::first_finderF<
                     BOOST_STRING_TYPENAME 
-                        const_iterator_of<ContainerT>::type,
+                        range_const_iterator<ContainerT>::type,
                     is_equal>( Search, is_equal() ) ;
         }
 
         //! "First" finder
         /*!
-            Construct the \c first_finder. The finder searches for the first
-            occurrence of the search sequence in a given input.
-            The result is given as a \c iterator_range delimiting the match.
-
-            Elements are compared using the given predicate.
-
-            \param Search A sequence to be searched for.
-            \param Comp An element comparison predicate
-            \return An instance of the \c first_finder object
+            \overload
         */
         template<typename ContainerT,typename PredicateT>
         inline detail::first_finderF<
-            BOOST_STRING_TYPENAME const_iterator_of<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             PredicateT>
         first_finder( 
             const ContainerT& Search, PredicateT Comp )
@@ -75,69 +72,63 @@ namespace boost {
             return 
                 detail::first_finderF<
                     BOOST_STRING_TYPENAME 
-                        const_iterator_of<ContainerT>::type,
+                        range_const_iterator<ContainerT>::type,
                     PredicateT>( Search, Comp );
         }
 
         //! "Last" finder
         /*!
             Construct the \c last_finder. The finder searches for the last
-            occurrence of the search sequence in a given input.
-            The result is given as a \c iterator_range delimiting the match.
+            occurrence of the string in a given input.
+            The result is given as an \c iterator_range delimiting the match.
 
-            \param Search A sequence to be searched for.
+            \param Search A substring to be searched for.
+            \param Comp An element comparison predicate
             \return An instance of the \c last_finder object
         */
         template<typename ContainerT>
         inline detail::last_finderF<
-            BOOST_STRING_TYPENAME const_iterator_of<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             is_equal>
         last_finder( const ContainerT& Search )
         {
             return 
                 detail::last_finderF<
                     BOOST_STRING_TYPENAME 
-                        const_iterator_of<ContainerT>::type,
+                        range_const_iterator<ContainerT>::type,
                     is_equal>( Search, is_equal() );
         }
         //! "Last" finder
         /*!
-            Construct the \c last_finder. The finder searches for the last
-            occurrence of the search sequence in a given input.
-            The result is given as a \c iterator_range delimiting the match.
-
-            Elements are compared using the given predicate.
-
-            \param Search A sequence to be searched for.
-            \param Comp An element comparison predicate
-            \return An instance of the \c last_finder object
+            \overload
         */
         template<typename ContainerT, typename PredicateT>
         inline detail::last_finderF<
-            BOOST_STRING_TYPENAME const_iterator_of<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             PredicateT>
         last_finder( const ContainerT& Search, PredicateT Comp )
         {
             return 
                 detail::last_finderF<
                     BOOST_STRING_TYPENAME 
-                        const_iterator_of<ContainerT>::type,
+                        range_const_iterator<ContainerT>::type,
                     PredicateT>( Search, Comp ) ;
         }
 
         //! "Nth" finder
         /*!
-            Construct the \c nth_finder. The finder searches for the n-th
-            occurrence of the search sequence in a given input.
-            The result is given as a \c iterator_range delimiting the match.
+            Construct the \c nth_finder. The finder searches for the n-th (zero-indexed)
+            occurrence of the string in a given input.
+            The result is given as an \c iterator_range delimiting the match.
 
-            \param Search A sequence to be searched for.
+            \param Search A substring to be searched for.
             \param Nth An index of the match to be find
+            \param Comp An element comparison predicate
             \return An instance of the \c nth_finder object
         */
         template<typename ContainerT>
         inline detail::nth_finderF<
-            BOOST_STRING_TYPENAME const_iterator_of<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             is_equal>
         nth_finder( 
             const ContainerT& Search, 
@@ -146,25 +137,16 @@ namespace boost {
             return 
                 detail::nth_finderF<
                     BOOST_STRING_TYPENAME 
-                        const_iterator_of<ContainerT>::type,
+                        range_const_iterator<ContainerT>::type,
                     is_equal>( Search, Nth, is_equal() ) ;
         }
         //! "Nth" finder
         /*!
-            Construct the \c nth_finder. The finder searches for the n-th
-            occurrence of the search sequence in a given input.
-            The result is given as a \c iterator_range delimiting the match.
-
-            Elements are compared using the given predicate.
-
-            \param Search A sequence to be searched for.
-            \param Nth An index of the match to be find
-            \param Comp An element comparison predicate
-            \return An instance of the \c nth_finder object
+            \overload
         */
         template<typename ContainerT, typename PredicateT>
         inline detail::nth_finderF<
-            BOOST_STRING_TYPENAME const_iterator_of<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             PredicateT>
         nth_finder( 
             const ContainerT& Search, 
@@ -174,17 +156,17 @@ namespace boost {
             return 
                 detail::nth_finderF<
                     BOOST_STRING_TYPENAME 
-                        const_iterator_of<ContainerT>::type,
+                        range_const_iterator<ContainerT>::type,
                     PredicateT>( Search, Nth, Comp );
         }
 
         //! "Head" finder
         /*!
             Construct the \c head_finder. The finder returns a head of a given
-            input. Head is a prefix of a sequence up to n elements in
+            input. The head is a prefix of a string up to n elements in
             size. If an input has less then n elements, whole input is 
             considered a head.
-            The result is given as a \c iterator_range delimiting the match.
+            The result is given as an \c iterator_range delimiting the match.
 
             \param N The size of the head
             \return An instance of the \c head_finder object
@@ -198,10 +180,10 @@ namespace boost {
         //! "Tail" finder
         /*!
             Construct the \c tail_finder. The finder returns a tail of a given
-            input. Tail is a suffix of the sequence up to n elements in
+            input. The tail is a suffix of a string up to n elements in
             size. If an input has less then n elements, whole input is 
             considered a head.
-            The result is given as a \c iterator_range delimiting the match.
+            The result is given as an \c iterator_range delimiting the match.
 
             \param N The size of the head
             \return An instance of the \c tail_finder object
@@ -219,12 +201,12 @@ namespace boost {
             algorithm, with an exception that it return a range of
             instead of a single iterator.
 
-            If bCompress is set to true, adjacent matching tokens are 
+            If "compress token mode" is enabled, adjacent matching tokens are 
             concatenated into one match. Thus the finder can be used to 
-            search for continuous segments of elements satisfying the 
+            search for continuous segments of characters satisfying the 
             given predicate.
 
-            The result is given as a \c iterator_range delimiting the match.
+            The result is given as an \c iterator_range delimiting the match.
 
             \param Pred An element selection predicate
             \param eCompress Compress flag
@@ -247,6 +229,7 @@ namespace boost {
 
             \param Begin Beginning of the range
             \param End End of the range
+            \param Range The range.
             \return An instance of the \c range_finger object
         */
         template< typename ForwardIteratorT >
@@ -259,9 +242,7 @@ namespace boost {
         }
 
         //! "Range" finder
-        /*!
-            \param Range The range.
-
+        /*!       
             \overload
         */
         template< typename ForwardIteratorT >

include/boost/algorithm/string/formatter.hpp

@@ -11,25 +11,26 @@
 #define BOOST_STRING_FORMATTER_HPP
 
 #include <boost/detail/iterator.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/iterator_range.hpp>
+
 #include <boost/algorithm/string/detail/formatter.hpp>
 
 /*! \file
-    Defines formatter generators. Formatter is a functor which formats
-    a string according to give parameters. A Formatter works
+    Defines Formatter generators. Formatter is a functor which formats
+    a string according to given parameters. A Formatter works
     in conjunction with a Finder. A Finder can provide additional information
-    for a specific Formatter. An example of such a cooperation is reger_finder
+    for a specific Formatter. An example of such a cooperation is regex_finder
     and regex_formatter.
 
-    Formatters are used by as a pluggable components for replace facilities. 
+    Formatters are used as pluggable components for replace facilities. 
     This header contains generator functions for the Formatters provided in this library.
 */
 
 namespace boost {
     namespace algorithm {
 
-// generic formaters  ---------------------------------------------------------------//
+// generic formatters  ---------------------------------------------------------------//
 
         //! Constant formatter
         /*!
@@ -39,11 +40,11 @@ namespace boost {
             \param Format A predefined value used as a result for formating
             \return An instance of the \c const_formatter object.
         */
-        template<typename CollectionT>
-        inline detail::const_formatF<CollectionT>
-        const_formatter(const CollectionT& Format)
+        template<typename RangeT>
+        inline detail::const_formatF<RangeT>
+        const_formatter(const RangeT& Format)
         {
-            return detail::const_formatF<CollectionT>(Format);
+            return detail::const_formatF<RangeT>(Format);
         }
 
         //! Identity formatter
@@ -53,29 +54,29 @@ namespace boost {
 
             \return An instance of the \c identity_formatter object.
         */
-        template<typename CollectionT>
-        inline detail::identity_formatF<CollectionT>
+        template<typename RangeT>
+        inline detail::identity_formatF<RangeT>
         identity_formatter()
         {
-            return detail::identity_formatF<CollectionT>();
+            return detail::identity_formatF<RangeT>();
         }
 
         //! Empty formatter
         /*!
-            Construct the \c empty_formatter. Empty formater always returns an empty
+            Construct the \c empty_formatter. Empty formatter always returns an empty
             sequence. 
 
             \param Input container used to select a correct value_type for the
                          resulting empty_container<>.
             \return An instance of the \c empty_formatter object.
         */
-        template<typename CollectionT>
+        template<typename RangeT>
         inline detail::empty_formatF< 
-            BOOST_STRING_TYPENAME value_type_of<CollectionT>::type>
-        empty_formatter(const CollectionT& Input)
+            BOOST_STRING_TYPENAME range_value<RangeT>::type>
+        empty_formatter(const RangeT&)
         {
             return detail::empty_formatF<
-                BOOST_STRING_TYPENAME value_type_of<CollectionT>::type>();
+                BOOST_STRING_TYPENAME range_value<RangeT>::type>();
         }
 
 

include/boost/algorithm/string/iter_find.hpp

@@ -14,8 +14,13 @@
 #include <algorithm>
 #include <iterator>
 #include <boost/iterator/transform_iterator.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/result_iterator.hpp>
+#include <boost/range/value_type.hpp>
+
 #include <boost/algorithm/string/concept.hpp>
 #include <boost/algorithm/string/find_iterator.hpp>
 #include <boost/algorithm/string/detail/util.hpp>
@@ -23,12 +28,12 @@
 /*! \file
     Defines generic split algorithms. Split algorithms can be 
     used to divide a sequence into several part according 
-    to a given criterium. Result is given as a 'container 
+    to a given criteria. Result is given as a 'container 
     of containers' where elements are copies or references 
     to extracted parts.
 
     There are two algorithms provided. One iterates over matching
-    substrings, the other one over the gasps between these matches.
+    substrings, the other one over the gaps between these matches.
 */
 
 namespace boost {
@@ -55,40 +60,47 @@ namespace boost {
             \param Finder A Finder object used for searching
             \return A reference the result
 
-            \note Prior content of the result will be overridden.
+            \note Prior content of the result will be overwritten.
         */
         template< 
             typename SequenceSequenceT,
-            typename CollectionT,
+            typename RangeT,
             typename FinderT >
         inline SequenceSequenceT&
         iter_find(
             SequenceSequenceT& Result,
-            CollectionT& Input,
+            RangeT& Input,
             FinderT Finder )
         {
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type> >();
+                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
 
             typedef BOOST_STRING_TYPENAME 
-                result_iterator_of<CollectionT>::type input_iterator_type;
+                range_result_iterator<RangeT>::type input_iterator_type;
             typedef find_iterator<input_iterator_type> find_iterator_type;
             typedef detail::copy_iterator_rangeF<
                 BOOST_STRING_TYPENAME 
-                    value_type_of<SequenceSequenceT>::type,
+                    range_value<SequenceSequenceT>::type,
                 input_iterator_type> copy_range_type;
             
             input_iterator_type InputEnd=end(Input);
 
-            SequenceSequenceT Tmp(
+            typedef transform_iterator<copy_range_type, find_iterator_type>
+                transform_iter_type;
+    
+            transform_iter_type itBegin=
                 make_transform_iterator( 
                     find_iterator_type( begin(Input), InputEnd, Finder ),
-                    copy_range_type() ),
+                    copy_range_type());
+            
+            transform_iter_type itEnd=
                 make_transform_iterator( 
                     find_iterator_type(),
-                    copy_range_type() ) );
+                    copy_range_type());
 
+            SequenceSequenceT Tmp(itBegin, itEnd);
+                        
             Result.swap(Tmp);
             return Result;
         }
@@ -115,40 +127,47 @@ namespace boost {
             \param Finder A finder object used for searching
             \return A reference the result
 
-            \note Prior content of the result will be overridden.
+            \note Prior content of the result will be overwritten.
         */
         template< 
             typename SequenceSequenceT,
-            typename CollectionT,
+            typename RangeT,
             typename FinderT >
         inline SequenceSequenceT&
         iter_split(
             SequenceSequenceT& Result,
-            CollectionT& Input,
+            RangeT& Input,
             FinderT Finder )
         {
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type> >();
+                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
 
             typedef BOOST_STRING_TYPENAME 
-                result_iterator_of<CollectionT>::type input_iterator_type;
+                range_result_iterator<RangeT>::type input_iterator_type;
             typedef split_iterator<input_iterator_type> find_iterator_type;
             typedef detail::copy_iterator_rangeF<
                 BOOST_STRING_TYPENAME 
-                    value_type_of<SequenceSequenceT>::type,
+                    range_value<SequenceSequenceT>::type,
                 input_iterator_type> copy_range_type;
             
             input_iterator_type InputEnd=end(Input);
 
-            SequenceSequenceT Tmp(
+            typedef transform_iterator<copy_range_type, find_iterator_type>
+                transform_iter_type;
+    
+            transform_iter_type itBegin=
                 make_transform_iterator( 
                     find_iterator_type( begin(Input), InputEnd, Finder ),
-                    copy_range_type() ),
+                    copy_range_type() );
+
+            transform_iter_type itEnd=
                 make_transform_iterator( 
                     find_iterator_type(),
-                    copy_range_type() ) );
+                    copy_range_type() );
             
+            SequenceSequenceT Tmp(itBegin, itEnd);
+
             Result.swap(Tmp);
             return Result;
         }

include/boost/algorithm/string/iterator_range.hpp

@@ -1,295 +0,0 @@
-//  Boost string_algo library iterator_range.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_ITERATOR_RANGE_HPP
-#define BOOST_STRING_ITERATOR_RANGE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <utility>
-#include <iterator>
-#include <algorithm>
-#include <ostream>
-#include <boost/detail/iterator.hpp>
-
-/*! \file
-    Defines the \c iterator_class and related functions. 
-    \c iterator_range is a simple wrapper of iterator pair idiom. It provides
-    a rich subset of Container interface.
-*/
-
-namespace boost {
-    namespace algorithm {
-
-//  iterator range template class -----------------------------------------//
-
-        //! iterator_range class
-        /*!
-            An \c iterator_range delimits a range in a sequence by beginning and ending iterators. 
-            An iterator_range can be passed to an algorithm which requires a sequence as an input. 
-            For example, the \c toupper() function may be used most frequently on strings, 
-            but can also be used on iterator_ranges: 
-            
-            \code
-                boost::tolower( find( s, "UPPERCASE STRING" ) );
-            \endcode
-
-            Many algorithms working with sequences take a pair of iterators, 
-            delimiting a working range, as an arguments. The \c iterator_range class is an 
-            encapsulation of a range identified by a pair of iterators. 
-            It provides a collection interface, 
-            so it is possible to pass an instance to an algorithm requiring a collection as an input. 
-        */
-        template<typename IteratorT> 
-        class iterator_range
-        {
-        public:
-            //! this type
-            typedef iterator_range<IteratorT> type;
-            //! Encapsulated value type
-            typedef BOOST_STRING_TYPENAME boost::detail::
-                iterator_traits<IteratorT>::value_type value_type;
-            //! Reference type
-            typedef BOOST_STRING_TYPENAME boost::detail::
-                iterator_traits<IteratorT>::reference reference;
-            //! Difference type
-            typedef BOOST_STRING_TYPENAME boost::detail::
-                iterator_traits<IteratorT>::difference_type difference_type;
-            //! Size type
-            typedef BOOST_STRING_TYPENAME boost::detail::
-                iterator_traits<IteratorT>::difference_type size_type;
-            
-            //! const_iterator type
-            /*! 
-                There is no distinction between const_iterator and iterator.
-                These typedefs are provides to fulfill container interface
-            */ 
-            typedef IteratorT const_iterator;
-            //! iterator type
-            typedef IteratorT iterator;
-
-            //! Default constructor
-            iterator_range() {}
-            
-            //! Constructor from a pair of iterators
-            iterator_range( iterator Begin, iterator End ) : 
-                m_Begin(Begin), m_End(End) {}
-
-            //! Constructor from a std::pair
-            iterator_range( const std::pair<IteratorT,IteratorT>& Range ) : 
-                m_Begin(Range.first), m_End(Range.second) {}
-
-            //! Copy constructor
-            iterator_range( const iterator_range& Other ) :
-                m_Begin(Other.begin()), m_End(Other.end()) {}
-
-            //! Templated copy constructor
-            /*!
-                This constructor is provided to allow conversion between
-                const and mutable iterator instances of this class template
-            */
-            template< typename OtherItT >
-            iterator_range( const iterator_range<OtherItT>& Other ) :
-                m_Begin(Other.begin()), m_End(Other.end()) {}
-
-            //! Assignment operator
-            iterator_range& operator=( const iterator_range& Other )
-            {
-                m_Begin=Other.begin(); m_End=Other.end();
-                return *this;
-            }
-
-            //! Assignment operator ( templated version )
-            template< typename OtherItT >
-            iterator_range& operator=( const iterator_range<OtherItT>& Other )
-            {
-                m_Begin=Other.begin(); m_End=Other.end();
-                return *this;
-            }
-            
-            //! Comparison operator ( equal )
-            /*! 
-                Compare operands for equality
-            */
-            template< typename OtherItT > 
-            bool operator==( const iterator_range<OtherItT>& Other ) const
-            {
-                return m_Begin==Other.begin() && m_End==Other.end();
-            }
-
-            //! Comparison operator ( not-equal )
-            /*! 
-                Compare operands for non-equality
-            */
-            template< typename OtherItT > 
-            bool operator!=( const iterator_range<OtherItT>& Other ) const
-            {
-                return m_Begin!=Other.begin() || m_End!=Other.end();
-            }
-
-            //! begin access
-            /*! 
-                Retrieve the begin iterator
-            */
-            IteratorT begin() const 
-            { 
-                return m_Begin; 
-            }
-
-            //! end access
-            /*!
-                Retrieve the end iterator
-            */
-            IteratorT end() const 
-            { 
-                return m_End; 
-            } 
-
-            //! Empty container test
-            /*!
-                Test whenever the range is empty
-            */
-            bool empty() const 
-            { 
-                return m_Begin==m_End; 
-            }
-            
-            //! Size of the range
-            /*!
-                Retrieve the size of the range
-            */
-            difference_type size() const
-            { 
-                return std::distance( m_Begin, m_End ); 
-            }
-
-            //! Swap
-            /*!
-                Swap two ranges
-            */
-            void swap( iterator_range& Other )
-            {
-                std::swap( m_Begin, Other.begin() );
-                std::swap( m_End, Other.end() );
-            }
-            
-            //! Safe bool conversion
-            /*!
-                Check whenever the range is empty.
-                Allows to use construction like this:
-                \code
-                    iterator_range r;
-                    if (!r)
-                    {
-                    ...
-                    }
-                \endcode
-            */
-            typedef iterator (iterator_range::*unspecified_bool_type) () const;
-            operator unspecified_bool_type() const
-            {
-                return empty()? 0: &iterator_range::end;
-            }
-
-        private:
-            // begin and end iterators
-            IteratorT m_Begin;
-            IteratorT m_End;
-        };
-
-//  iterator range free-standing operators ---------------------------//
-
-        //! iterator_range output operator
-        /*!
-            Output the range to an ostream. Elements are outputed
-            in a sequence without separators.
-        */
-        template< typename IteratorT, typename Elem, typename Traits >
-        std::basic_ostream<Elem,Traits>& operator<<( 
-            std::basic_ostream<Elem, Traits>& Os,
-            const iterator_range<IteratorT>& Range )
-        {
-            std::copy(Range.begin(), Range.end(), std::ostream_iterator<Elem>(Os));
-
-            return Os;
-        }
-
-
-//  iterator range utilities -----------------------------------------//
-
-        //! iterator_range construct helper 
-        /*!
-            Construct an \c iterator_range from a pair of iterators
-
-            \param Begin A begin iterator
-            \param End An end iterator
-            \return iterator_range object
-        */
-        template< typename IteratorT >
-        inline iterator_range< IteratorT > make_iterator_range( IteratorT Begin, IteratorT End ) 
-        {   
-            return iterator_range<IteratorT>( Begin, End );
-        }
-      
-        //! iterator_range construct helper
-        /*!
-            Construct an \c iterator_range from a \c std::pair<> containing the begin
-            and end iterators.
-
-            \param Pair A \c std::pair<> with begin and end iterators
-            \return \c iterator_range object
-        */
-        template< typename IteratorT >
-        inline iterator_range< IteratorT > make_iterator_range( const std::pair<IteratorT,IteratorT>& Pair ) 
-        {   
-            return iterator_range<IteratorT>( Pair.first, Pair.second );
-        }
-
-        //! copy a range into a sequence
-        /*!
-            Construct a new sequence of the specified type from the elements
-            in the given range
-
-            \param Range An input range
-            \return New sequence
-        */
-        template< typename SeqT, typename IteratorT >
-        inline SeqT copy_iterator_range( const iterator_range<IteratorT>& Range )
-        {
-            return SeqT( Range.begin(), Range.end() );
-        }
-
-        //! transform a range into a sequence
-        /*!
-            Create a new sequence from the elements in the range, transformed
-            by a function
-
-            \param Range An input range
-            \param Func Transformation function
-            \return New sequence
-        */
-        template< typename SeqT, typename IteratorT, typename FuncT >
-        inline SeqT transform_iterator_range( const iterator_range<IteratorT>& Range, FuncT Func )
-        {
-            SeqT Seq;
-            std::transform( Range.begin(), Range.end(), std::back_inserter(Seq), Func );
-            return Seq;
-        }
-
-    } // namespace algorithm
-    
-    // pull names to the namespace boost
-    using algorithm::iterator_range;
-    using algorithm::make_iterator_range;
-    using algorithm::copy_iterator_range;
-    using algorithm::transform_iterator_range;
-
-} // namespace boost
-
-
-#endif  // BOOST_STRING_ITERATOR_RANGE_HPP

include/boost/algorithm/string/predicate.hpp

@@ -11,18 +11,24 @@
 #define BOOST_STRING_PREDICATE_HPP
 
 #include <boost/algorithm/string/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+
 #include <boost/algorithm/string/compare.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
 #include <boost/algorithm/string/find.hpp>
 #include <boost/algorithm/string/detail/predicate.hpp>
 
 /*! \file boost/algorithm/string/predicate.hpp
     Defines string-related predicates. 
-    The predicates are resolving if a substring is contained in the input string 
-    under various conditions. If a string starts with the substring, ends with the 
+    The predicates determine whether a substring is contained in the input string 
+    under various conditions: a string starts with the substring, ends with the 
     substring, simply contains the substring or if both strings are equal.
-    In addition the algorithm \c all() checks all elements of a container to satisfy a 
+    Additionaly the algorithm \c all() checks all elements of a container to satisfy a 
     condition.
+
+    All predicates provide the strong exception guarantee.
 */
 
 namespace boost {
@@ -32,24 +38,28 @@ namespace boost {
 
         //! 'Starts with' predicate
         /*!
-            This predicate holds when the test collection is a prefix of the Input.
-            In other word, if the input starts with the test.
+            This predicate holds when the test string is a prefix of the Input.
+            In other words, if the input starts with the test.
+            When the optional predicate is specified, it is used for character-wise
+            comparison.
 
             \param Input An input sequence
             \param Test A test sequence
             \param Comp An element comparison predicate
-            \return A result of the test
+            \return The result of the test
+
+              \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T, typename PredicateT>
+        template<typename Range1T, typename Range2T, typename PredicateT>
             inline bool starts_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             PredicateT Comp)
         {
             typedef BOOST_STRING_TYPENAME 
-                const_iterator_of<Collection1T>::type Iterator1T;
+                range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME 
-                const_iterator_of<Collection2T>::type Iterator2T;
+                range_const_iterator<Range2T>::type Iterator2T;
 
             Iterator1T InputEnd=end(Input);
             Iterator2T TestEnd=end(Test);
@@ -69,36 +79,33 @@ namespace boost {
 
         //! 'Starts with' predicate
         /*!
-            This predicate holds when the test container is a prefix of the Input.
-            In other words, if the input starts with the test.
-
-            \param Input An input sequence
-            \param Test A test sequence
-            \return A result of the test
+            \overload
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool starts_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test)
+            const Range1T& Input, 
+            const Range2T& Test)
         {
             return starts_with(Input, Test, is_equal());
         }
 
         //! 'Starts with' predicate ( case insensitive )
         /*!
-            This predicate holds when the test container is a prefix of the Input.
-            In other word, if the input starts with the test.
+            This predicate holds when the test string is a prefix of the Input.
+            In other words, if the input starts with the test.
             Elements are compared case insensitively.
 
             \param Input An input sequence
             \param Test A test sequence
-            \param Loc a locale used for case insensitive comparison
-            \return A result of the test
+            \param Loc A locale used for case insensitive comparison
+            \return The result of the test
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool istarts_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
             return starts_with(Input, Test, is_iequal(Loc));
@@ -109,22 +116,27 @@ namespace boost {
 
         //! 'Ends with' predicate
         /*!
-            This predicate holds when the test container is a suffix of the Input.
-            In other word, if the input ends with the test.
+            This predicate holds when the test string is a suffix of the Input.
+            In other words, if the input ends with the test.
+            When the optional predicate is specified, it is used for character-wise
+            comparison.
+
 
             \param Input An input sequence
             \param Test A test sequence
             \param Comp An element comparison predicate
-            \return A result of the test
+            \return The result of the test
+
+              \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T, typename PredicateT>
+        template<typename Range1T, typename Range2T, typename PredicateT>
         inline bool ends_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             PredicateT Comp)
         {
             typedef BOOST_STRING_TYPENAME 
-                const_iterator_of<Collection1T>::type Iterator1T;
+                range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME boost::detail::
                 iterator_traits<Iterator1T>::iterator_category category;
 
@@ -141,17 +153,12 @@ namespace boost {
 
         //! 'Ends with' predicate
         /*!
-            This predicate holds when the test container is a suffix of the Input.
-            In other word, if the input ends with the test.
-
-            \param Input An input sequence
-            \param Test A test sequence
-            \return A result of the test
+            \overload
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool ends_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test)
+            const Range1T& Input, 
+            const Range2T& Test)
         {
             return ends_with(Input, Test, is_equal());
         }
@@ -159,18 +166,20 @@ namespace boost {
         //! 'Ends with' predicate ( case insensitive )
         /*!
             This predicate holds when the test container is a suffix of the Input.
-            In other word, if the input ends with the test.
+            In other words, if the input ends with the test.
             Elements are compared case insensitively.
 
             \param Input An input sequence
             \param Test A test sequence
-            \param Loc a locale used for case insensitive comparison
-            \return A result of the test
+            \param Loc A locale used for case insensitive comparison
+            \return The result of the test
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool iends_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
             return ends_with(Input, Test, is_iequal(Loc));
@@ -181,16 +190,20 @@ namespace boost {
         //! 'Contains' predicate
         /*!
             This predicate holds when the test container is contained in the Input.
-            
+            When the optional predicate is specified, it is used for character-wise
+            comparison.
+
             \param Input An input sequence
             \param Test A test sequence
             \param Comp An element comparison predicate
-            \return A result of the test
+            \return The result of the test
+
+               \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T, typename PredicateT>
+        template<typename Range1T, typename Range2T, typename PredicateT>
         inline bool contains( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             PredicateT Comp)
         {
             if (empty(Test))
@@ -199,21 +212,19 @@ namespace boost {
                 return true;
             }
             
-            return (first_finder(Test,Comp)(begin(Input), end(Input)));
+            // Use the temporary variable to make VACPP happy
+            bool bResult=(first_finder(Test,Comp)(begin(Input), end(Input)));
+            return bResult;
         }
 
         //! 'Contains' predicate
         /*!
-            This predicate holds when the test container is contained in the Input.
-            
-            \param Input An input sequence
-            \param Test A test sequence
-            \return A result of the test
+            \overload
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool contains( 
-            const Collection1T& Input, 
-            const Collection2T& Test)
+            const Range1T& Input, 
+            const Range2T& Test)
         {
             return contains(Input, Test, is_equal());
         }
@@ -225,13 +236,15 @@ namespace boost {
 
             \param Input An input sequence
             \param Test A test sequence
-            \param Loc a locale used for case insensitive comparison
-            \return A result of the test
+            \param Loc A locale used for case insensitive comparison
+            \return The result of the test
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool icontains( 
-            const Collection1T& Input, 
-            const Collection2T& Test, 
+            const Range1T& Input, 
+            const Range2T& Test, 
             const std::locale& Loc=std::locale())
         {
             return contains(Input, Test, is_iequal(Loc));
@@ -243,22 +256,28 @@ namespace boost {
         /*!
             This predicate holds when the test container is equal to the
             input container i.e. all elements in both containers are same.
-            
+            When the optional predicate is specified, it is used for character-wise
+            comparison.
+
             \param Input An input sequence
             \param Test A test sequence
             \param Comp An element comparison predicate
-            \return A result of the test
+            \return The result of the test
+
+            \note This is a two-way version of \c std::equal algorithm
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T, typename PredicateT>
+        template<typename Range1T, typename Range2T, typename PredicateT>
         inline bool equals( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             PredicateT Comp)
         {
             typedef BOOST_STRING_TYPENAME 
-                const_iterator_of<Collection1T>::type Iterator1T;
+                range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME 
-                const_iterator_of<Collection2T>::type Iterator2T;
+                range_const_iterator<Range2T>::type Iterator2T;
                 
             Iterator1T InputEnd=end(Input);
             Iterator2T TestEnd=end(Test);
@@ -278,19 +297,12 @@ namespace boost {
 
         //! 'Equals' predicate
         /*!
-            This predicate holds when the test container is equal to the
-            input container i.e. all elements in both containers are same.
-            
-            \param Input An input sequence
-            \param Test A test sequence
-            \return A result of the test
-
-            \note This is two-way version of \c std::equal algorithm
+            \overload
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool equals( 
-            const Collection1T& Input, 
-            const Collection2T& Test)
+            const Range1T& Input, 
+            const Range2T& Test)
         {
             return equals(Input, Test, is_equal());
         }
@@ -303,15 +315,17 @@ namespace boost {
 
             \param Input An input sequence
             \param Test A test sequence
-            \param Loc a locale used for case insensitive comparison
-            \return A result of the test
+            \param Loc A locale used for case insensitive comparison
+            \return The result of the test
 
-            \note This is two-way version of \c std::equal algorithm
+            \note This is a two-way version of \c std::equal algorithm
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool iequals( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
             return equals(Input, Test, is_iequal(Loc));
@@ -326,15 +340,17 @@ namespace boost {
             
             \param Input An input sequence
             \param Pred A predicate
-            \return A result of the test
+            \return The result of the test
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template<typename CollectionT, typename PredicateT>
+        template<typename RangeT, typename PredicateT>
         inline bool all( 
-            const CollectionT& Input, 
+            const RangeT& Input, 
             PredicateT Pred)
         {
             typedef BOOST_STRING_TYPENAME 
-                const_iterator_of<CollectionT>::type Iterator1T;
+                range_const_iterator<RangeT>::type Iterator1T;
 
             Iterator1T InputEnd=end(Input);
             for( Iterator1T It=begin(Input); It!=InputEnd; ++It)

include/boost/algorithm/string/predicate_facade.hpp

@@ -0,0 +1,41 @@
+//  Boost string_algo library predicate_facade.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003. Use, modification and
+//  distribution is subject to 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 for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_PREDICATE_FACADE_HPP
+#define BOOST_STRING_PREDICATE_FACADE_HPP
+
+#include <boost/algorithm/string/config.hpp>
+
+/*
+ \file boost/algorith/string/predicate_facade.hpp
+ This file containes predicate_facade definition. This template class is used
+ to identify classification predicates, so they can be combined using
+ composition operators.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  predicate facade ------------------------------------------------------//
+
+        //! Predicate facade
+        /*!
+            This class allows to recognize classification
+            predicates, so that they can be combined using
+            composition operators.
+            Every classification predicate must be derived from this class.
+        */
+        template<typename Derived>
+        struct predicate_facade {};
+
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_CLASSIFICATION_DETAIL_HPP

include/boost/algorithm/string/regex.hpp

@@ -12,15 +12,19 @@
 
 #include <boost/algorithm/string/config.hpp>
 #include <boost/regex.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/result_iterator.hpp>
+
 #include <boost/algorithm/string/find_format.hpp>
 #include <boost/algorithm/string/regex_find_format.hpp>
 #include <boost/algorithm/string/formatter.hpp>
 #include <boost/algorithm/string/iter_find.hpp>
 
 /*! \file
-    Defines regex variant of the algorithms. 
+    Defines regex variants of the algorithms. 
 */
 
 namespace boost {
@@ -30,26 +34,28 @@ namespace boost {
 
         //! Find regex algorithm
         /*!
-            Search for a subsequence matching the given regex in the input.
+            Search for a substring matching the given regex in the input.
             
             \param Input A container which will be searched.
             \param Rx A regular expression
             \param Flags Regex options
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c InputContainerT::iterator or 
-                \c InputContainerT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
+
+              \note This function provides the strong exception-safety guarantee
         */
         template< 
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT>
+            typename RegexTraitsT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type >
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type >
         find_regex( 
-            CollectionT& Input, 
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            RangeT& Input, 
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             return regex_finder(Rx,Flags)(
@@ -60,26 +66,31 @@ namespace boost {
 
         //! Replace regex algorithm
         /*!
-            Search for a subsequence matching given regex and format it with 
-            the specified format. The result is copied to the given output iterator.
+            Search for a substring matching given regex and format it with 
+            the specified format.             
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
             \param Rx A regular expression
             \param Format Regex format definition
             \param Flags Regex options
-            \return An output iterator pointing just after last inserted character
+            \return An output iterator pointing just after the last inserted character or
+                    a modified copy of the input   
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT,
+            typename RegexTraitsT,
             typename FormatStringTraitsT, typename FormatStringAllocatorT >
         inline OutputIteratorT replace_regex_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const RangeT& Input,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
@@ -92,23 +103,16 @@ namespace boost {
 
         //! Replace regex algorithm
         /*!
-            Search for a subsequence matching given regex and format it with 
-            the specified format. The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param Rx A regular expression
-            \param Format Regex format definition
-            \param Flags Regex options
-            \return A modified copy of the input
+            \overload
         */
         template< 
             typename SequenceT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT,
+            typename RegexTraitsT,
             typename FormatStringTraitsT, typename FormatStringAllocatorT >
         inline SequenceT replace_regex_copy( 
             const SequenceT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
@@ -120,10 +124,10 @@ namespace boost {
 
         //! Replace regex algorithm
         /*!
-            Search for a subsequence matching given regex and format it with 
-            the specified format. The input sequence is modified in-place.
+            Search for a substring matching given regex and format it with 
+            the specified format. The input string is modified in-place.
 
-            \param Input An input sequence
+            \param Input An input string
             \param Rx A regular expression
             \param Format Regex format definition
             \param Flags Regex options
@@ -131,11 +135,11 @@ namespace boost {
         template< 
             typename SequenceT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT,
+            typename RegexTraitsT,
             typename FormatStringTraitsT, typename FormatStringAllocatorT >
         inline void replace_regex( 
             SequenceT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
@@ -149,26 +153,30 @@ namespace boost {
 
         //! Replace all regex algorithm
         /*!
-            Format all subsequences, matching given regex, with the specified format. 
-            The result is copied to the given output iterator.
+            Format all substrings, matching given regex, with the specified format. 
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
             \param Rx A regular expression
             \param Format Regex format definition
             \param Flags Regex options
-            \return An output iterator pointing just after last inserted character
+            \return An output iterator pointing just after the last inserted character or
+                    a modified copy of the input     
+
+              \note The second variant of this function provides the strong exception-safety guarantee
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT,
+            typename RegexTraitsT,
             typename FormatStringTraitsT, typename FormatStringAllocatorT >
         inline OutputIteratorT replace_all_regex_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const RangeT& Input,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
@@ -181,23 +189,16 @@ namespace boost {
 
         //! Replace all regex algorithm
         /*!
-            Format all subsequences, mathing given regex, with the specified format. 
-            The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param Rx A regular expression
-            \param Format Regex format definition
-            \param Flags Regex options
-            \return A modified copy of the input
+            \overload
         */
         template< 
             typename SequenceT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT,
+            typename RegexTraitsT,
             typename FormatStringTraitsT, typename FormatStringAllocatorT >
         inline SequenceT replace_all_regex_copy( 
             const SequenceT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
@@ -209,22 +210,22 @@ namespace boost {
 
         //! Replace all regex algorithm
         /*!
-            Format all subsequences, matching given regex, with the specified format. 
-            The input sequence is modified in-place.
+            Format all substrings, matching given regex, with the specified format. 
+            The input string is modified in-place.
 
-            \param Input An input sequence
+            \param Input An input string
             \param Rx A regular expression
             \param Format Regex format definition
-            \param Flags Regex options
+            \param Flags Regex options            
         */
         template< 
             typename SequenceT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT,
+            typename RegexTraitsT,
             typename FormatStringTraitsT, typename FormatStringAllocatorT >
         inline void replace_all_regex( 
             SequenceT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
@@ -238,24 +239,28 @@ namespace boost {
 
         //! Erase regex algorithm
         /*!
-            Remove a subsequence matching given regex from the input.
-            The result is copied to the given output iterator.
+            Remove a substring matching given regex from the input.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.                        
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
             \param Rx A regular expression
             \param Flags Regex options
-            \return An output iterator pointing just after last inserted character
-        */
+            \return An output iterator pointing just after the last inserted character or
+                       a modified copy of the input    
+
+             \note The second variant of this function provides the strong exception-safety guarantee
+       */
         template< 
             typename OutputIteratorT,
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT >
+            typename RegexTraitsT >
         inline OutputIteratorT erase_regex_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const RangeT& Input,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             return find_format_copy(
@@ -267,21 +272,15 @@ namespace boost {
 
         //! Erase regex algorithm
         /*!
-            Remove a subsequence matching given regex from the input.
-            The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param Rx A regular expression
-            \param Flags Regex options
-            \return A modified copy of the input
+            \overload
         */
         template< 
             typename SequenceT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT >
+            typename RegexTraitsT >
         inline SequenceT erase_regex_copy( 
             const SequenceT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             return find_format_copy( 
@@ -292,20 +291,20 @@ namespace boost {
 
         //! Erase regex algorithm
         /*!
-            Remove a subsequence matching given regex from the input.
-            The input sequence is modified in-place.
+            Remove a substring matching given regex from the input.
+            The input string is modified in-place.
 
-            \param Input An input sequence
+            \param Input An input string
             \param Rx A regular expression
             \param Flags Regex options
         */
         template< 
             typename SequenceT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT >
+            typename RegexTraitsT >
         inline void erase_regex( 
             SequenceT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             find_format( 
@@ -318,24 +317,29 @@ namespace boost {
 
         //! Erase all regex algorithm
         /*!
-            Erase all subsequences, matching given regex, from the input.
-            The result is copied to the given output iterator.
+            Erase all substrings, matching given regex, from the input.
+            The result is a modified copy of the input. It is returned as a sequence 
+            or copied to the output iterator.
+            
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input sequence
+            \param Output An output iterator to which the result will be copied
+            \param Input An input string
             \param Rx A regular expression
             \param Flags Regex options
-            \return An output iterator pointing just after last inserted character
+            \return An output iterator pointing just after the last inserted character or
+                    a modified copy of the input                        
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT >
+            typename RegexTraitsT >
         inline OutputIteratorT erase_all_regex_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const RangeT& Input,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             return find_format_all_copy(
@@ -347,21 +351,15 @@ namespace boost {
 
         //! Erase all regex algorithm
         /*!
-            Erase all subsequences, matching given regex, from the input.
-            The result is a modified copy of the input.
-
-            \param Input An input sequence
-            \param Rx A regular expression
-            \param Flags Regex options
-            \return A modified copy of the input
+            \overload
         */
         template< 
             typename SequenceT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT >
+            typename RegexTraitsT >
         inline SequenceT erase_all_regex_copy( 
             const SequenceT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             return find_format_all_copy( 
@@ -372,20 +370,20 @@ namespace boost {
 
         //! Erase all regex algorithm
         /*!
-            Erase all subsequences, matching given regex, from the input.
-            The input sequence is modified in-place.
+            Erase all substrings, matching given regex, from the input.
+            The input string is modified in-place.
 
-            \param Input An input sequence
+            \param Input An input string
             \param Rx A regular expression
             \param Flags Regex options
         */
         template< 
             typename SequenceT, 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT>
+            typename RegexTraitsT>
         inline void erase_all_regex( 
             SequenceT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             find_format_all( 
@@ -399,33 +397,34 @@ namespace boost {
         //! Find all regex algorithm
         /*!
             This algorithm finds all substrings matching the give regex
-            in the input. The result is given as a 'container of containers'.
-            Each match of the search sequence is represented by one
-            element in the result.
+            in the input.             
+            
+            Each part is copied and added as a new element to the output container.
+            Thus the result container must be able to hold copies
+            of the matches (in a compatible structure like std::string) or
+            a reference to it (e.g. using the iterator range class).
+            Examples of such a container are \c std::vector<std::string>
+            or \c std::list<boost::iterator_range<std::string::iterator>>
 
-            \param Result A 'container container' to container the result of search.
-                Both outer and inner container must have constructor taking a pair
-                of iterators as an argument.
-                Typical type of the result is 
-                    \c std::vector<boost::iterator_range<iterator>>.
-                (each element of such a vector will container a range delimiting 
-                a match).
+            \param Result A container that can hold copies of references to the substrings.
             \param Input A container which will be searched.
             \param Rx A regular expression
             \param Flags Regex options
             \return A reference to the result
 
-            \note Prior content of the result will be overridden.
+            \note Prior content of the result will be overwritten.
+
+             \note This function provides the strong exception-safety guarantee
         */
         template< 
             typename SequenceSequenceT, 
-            typename CollectionT,         
+            typename RangeT,         
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT >
+            typename RegexTraitsT >
         inline SequenceSequenceT& find_all_regex(
             SequenceSequenceT& Result,
-            const CollectionT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const RangeT& Input,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             return iter_find(
@@ -438,33 +437,35 @@ namespace boost {
 
         //! Split regex algorithm
         /*! 
-            Tokenize expression. This function is equivalent of C strtok. Input
+            Tokenize expression. This function is equivalent to C strtok. Input
             sequence is split into tokens, separated  by separators. Separator
             is an every match of the given regex.
-
-            \param Result A 'container container' to container the result of search.
-                Both outer and inner container must have constructor taking a pair
-                of iterators as an argument.
-                Typical type of the result is 
-                    'c std::vector<boost::iterator_range<iterator>>.
-                (each element of such a vector will container a range delimiting 
-                a match).
+            Each part is copied and added as a new element to the output container.
+            Thus the result container must be able to hold copies
+            of the matches (in a compatible structure like std::string) or
+            a reference to it (e.g. using the iterator range class).
+            Examples of such a container are \c std::vector<std::string>
+            or \c std::list<boost::iterator_range<std::string::iterator>>
+    
+            \param Result A container that can hold copies of references to the substrings.          
             \param Input A container which will be searched.
             \param Rx A regular expression
             \param Flags Regex options
             \return A reference to the result
 
-            \note Prior content of the result will be overridden.
+            \note Prior content of the result will be overwritten.
+
+               \note This function provides the strong exception-safety guarantee
         */
         template< 
             typename SequenceSequenceT, 
-            typename CollectionT,         
+            typename RangeT,         
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT >
+            typename RegexTraitsT >
         inline SequenceSequenceT& split_regex(
             SequenceSequenceT& Result,
-            const CollectionT& Input,
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const RangeT& Input,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
             return iter_split(

include/boost/algorithm/string/regex_find_format.hpp

@@ -16,9 +16,9 @@
 #include <boost/algorithm/string/detail/formatter_regex.hpp>
 
 /*! \file
-    Defines the \c refex_finder and \c regex_formatter generators. These two functors
+    Defines the \c regex_finder and \c regex_formatter generators. These two functors
     are designed to work together. \c regex_formatter uses additional information
-    about a match contained in the reger_finder search result.
+    about a match contained in the regex_finder search result.
 */
 
 namespace boost {
@@ -28,7 +28,7 @@ namespace boost {
 
         //! "Regex" finder 
         /*!
-            Construct the \c regex_finder. Finder uses regex engine to search
+            Construct the \c regex_finder. Finder uses the regex engine to search
             for a match.
             Result is given in \c regex_search_result. This is an extension
             of the iterator_range. In addition it containes match results 
@@ -40,22 +40,22 @@ namespace boost {
         */
         template< 
             typename CharT, 
-            typename RegexTraitsT, typename RegexAllocatorT>
-        inline detail::find_regexF< reg_expression<CharT, RegexTraitsT, RegexAllocatorT> >
+            typename RegexTraitsT>
+        inline detail::find_regexF< basic_regex<CharT, RegexTraitsT> >
         regex_finder(
-            const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx,
+            const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type MatchFlags=match_default )
         {
             return detail::
                 find_regexF< 
-                    reg_expression<CharT, RegexTraitsT, RegexAllocatorT> >( Rx, MatchFlags );
+                    basic_regex<CharT, RegexTraitsT> >( Rx, MatchFlags );
         }
 
 //  regex_formater  ---------------------------------------------//
 
         //! Regex formatter
         /*!
-            Construct the \c regex_formatter. Regex formatter uses regex engine to
+            Construct the \c regex_formatter. Regex formatter uses the regex engine to
             format a match found by the \c regex_finder. 
             This formatted it designed to closely cooperate with \c regex_finder.
 
@@ -78,6 +78,11 @@ namespace boost {
         }
 
     } // namespace algorithm
+
+    // pull the names to the boost namespace
+    using algorithm::regex_finder;
+    using algorithm::regex_formatter;
+
 } // namespace boost
 
 

include/boost/algorithm/string/sequence_traits.hpp

@@ -22,12 +22,12 @@
     For lacking compilers, it is possible of define an override for a specific tester
     function.
 
-    Due to language restriction, it is not currently possible to define specialization for
-    stl containers without including the coresponding header. To decrease the overhead
-    needed by this inclusion, user can selectively include specialization 
+    Due to a language restriction, it is not currently possible to define specializations for
+    stl containers without including the corresponding header. To decrease the overhead
+    needed by this inclusion, user can selectively include a specialization
     header for a specific container. They are located in boost/algorithm/string/stl
     directory. Alternatively she can include boost/algorithm/string/std_collection_traits.hpp
-    header which contains specialization for all stl containers.
+    header which contains specializations for all stl containers.
 */
 
 namespace boost {
@@ -39,7 +39,7 @@ namespace boost {
 
         //! Native replace tester
         /*!
-            Declare an override of this tester function with return 
+            Declare an override of this tester function with return
             type boost::string_algo::yes_type for a sequence with this property.
 
             \return yes_type if the container has basic_string like native replace
@@ -49,31 +49,31 @@ namespace boost {
 
         //! Stable iterators tester
         /*!
-            Declare an override of this tester function with return 
+            Declare an override of this tester function with return
             type boost::string_algo::yes_type for a sequence with this property.
 
-            \return yes_type if the seqeunce's insert/replace/erase methods do not invalidate
+            \return yes_type if the sequence's insert/replace/erase methods do not invalidate
             existing iterators.
         */
-        no_type has_stable_iterators_tester(...);                     
+        no_type has_stable_iterators_tester(...);
 
         //! const time insert tester
         /*!
-            Declare an override of this tester function with return 
+            Declare an override of this tester function with return
             type boost::string_algo::yes_type for a sequence with this property.
 
             \return yes_type if the sequence's insert method is working in constant time
         */
-        no_type has_const_time_insert_tester(...);                        
+        no_type has_const_time_insert_tester(...);
 
         //! const time erase tester
         /*!
-            Declare an override of this tester function with return 
+            Declare an override of this tester function with return
             type boost::string_algo::yes_type for a sequence with this property.
 
             \return yes_type if the sequence's erase method is working in constant time
         */
-        no_type has_const_time_erase_tester(...);                        
+        no_type has_const_time_erase_tester(...);
 
 #endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
@@ -89,21 +89,25 @@ namespace boost {
         private:
             static T* t;
         public:
-            BOOST_STATIC_CONSTANT(bool, value=( 
+            BOOST_STATIC_CONSTANT(bool, value=(
                 sizeof(has_native_replace_tester(t))==sizeof(yes_type) ) );
 #else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    public:
+        public:
+#    if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = false };
+#    else
             BOOST_STATIC_CONSTANT(bool, value=false);
+#    endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    
 
-            typedef mpl::bool_<value> type;     
+
+            typedef mpl::bool_<has_native_replace<T>::value> type;
         };
 
 
         //! Stable iterators trait
         /*!
-            This trait specifies that the sequence has stable iterators. It means,
+            This trait specifies that the sequence has stable iterators. It means
             that operations like insert/erase/replace do not invalidate iterators.
         */
         template< typename T >
@@ -113,20 +117,24 @@ namespace boost {
         private:
             static T* t;
         public:
-            BOOST_STATIC_CONSTANT(bool, value=( 
+            BOOST_STATIC_CONSTANT(bool, value=(
                 sizeof(has_stable_iterators_tester(t))==sizeof(yes_type) ) );
 #else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    public:
+        public:
+#    if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = false };
+#    else
             BOOST_STATIC_CONSTANT(bool, value=false);
+#    endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
-            typedef mpl::bool_<value> type;
+            typedef mpl::bool_<has_stable_iterators<T>::value> type;
         };
 
 
         //! Const time insert trait
         /*!
-            This trait specifies that the sequence's insert method has 
+            This trait specifies that the sequence's insert method has
             constant time complexity.
         */
         template< typename T >
@@ -136,20 +144,24 @@ namespace boost {
         private:
             static T* t;
         public:
-            BOOST_STATIC_CONSTANT(bool, value=( 
+            BOOST_STATIC_CONSTANT(bool, value=(
                 sizeof(has_const_time_insert_tester(t))==sizeof(yes_type) ) );
 #else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    public:
+        public:
+#    if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = false };
+#    else
             BOOST_STATIC_CONSTANT(bool, value=false);
+#    endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
-            typedef mpl::bool_<value> type;
+            typedef mpl::bool_<has_const_time_insert<T>::value> type;
         };
 
 
         //! Const time erase trait
         /*!
-            This trait specifies that the sequence's erase method has 
+            This trait specifies that the sequence's erase method has
             constant time complexity.
         */
         template< typename T >
@@ -159,14 +171,18 @@ namespace boost {
         private:
             static T* t;
         public:
-            BOOST_STATIC_CONSTANT(bool, value=( 
+            BOOST_STATIC_CONSTANT(bool, value=(
                 sizeof(has_const_time_erase_tester(t))==sizeof(yes_type) ) );
 #else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    public:
+        public:
+#    if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = false };
+#    else
             BOOST_STATIC_CONSTANT(bool, value=false);
+#    endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
-            typedef mpl::bool_<value> type;
+            typedef mpl::bool_<has_const_time_erase<T>::value> type;
         };
 
     } // namespace algorithm

include/boost/algorithm/string/split.hpp

@@ -11,20 +11,23 @@
 #define BOOST_STRING_SPLIT_HPP
 
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/algorithm/string/iterator_range.hpp>
+
 #include <boost/algorithm/string/iter_find.hpp>
 #include <boost/algorithm/string/finder.hpp>
 #include <boost/algorithm/string/compare.hpp>
 
 /*! \file
     Defines basic split algorithms. 
-    Split algorithms can be used to divide a sequence
-    into several parts according to a given criterium.
-    Result is given as a 'container of containers' where
-    elements are copies or references to extracted parts.
-    This file contains some common specializations of generic
-    algorithms contained in the file split2.hpp
+    Split algorithms can be used to divide a string
+    into several parts according to given criteria.
+    
+    Each part is copied and added as a new element to the
+    output container.
+    Thus the result container must be able to hold copies
+    of the matches (in a compatible structure like std::string) or
+    a reference to it (e.g. using the iterator range class).
+    Examples of such a container are \c std::vector<std::string>
+    or \c std::list<boost::iterator_range<std::string::iterator>>
 */
 
 namespace boost {
@@ -34,29 +37,31 @@ namespace boost {
 
         //! Find all algorithm
         /*!
-            This algorithm finds all occurrences of the search sequence
-            in the input. A result is given as a 'container of containers'.
-            Each match of the search sequence is represented by one
-            element in the result.
+            This algorithm finds all occurrences of the search string
+            in the input.
+            
+            Each part is copied and added as a new element to the
+            output container.
+            Thus the result container must be able to hold copies
+            of the matches (in a compatible structure like std::string) or
+            a reference to it (e.g. using the iterator range class).
+            Examples of such a container are \c std::vector<std::string>
+            or \c std::list<boost::iterator_range<std::string::iterator>>
 
-            \param Result A 'container container' to container the result of search.
-                Both outer and inner container must have constructor taking a pair
-                of iterators as an argument.
-                Typical type of the result is 
-                    \c std::vector<boost::iterator_range<iterator>).
-                (each element of such a vector will container a range delimiting 
-                a match).
+            \param Result A container that can hold copies of references to the substrings
             \param Input A container which will be searched.
-            \param Search A string to be searched for.
+            \param Search A substring to be searched for.
             \return A reference the result
 
-            \note Prior content of the result will be overridden.
+            \note Prior content of the result will be overwritten.
+
+               \note This function provides the strong exception-safety guarantee
         */
-        template< typename SequenceSequenceT, typename Collection1T, typename Collection2T >
+        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
         inline SequenceSequenceT& find_all(
             SequenceSequenceT& Result,
-            Collection1T& Input,
-            const Collection2T& Search)
+            Range1T& Input,
+            const Range2T& Search)
         {
             return iter_find(
                 Result,
@@ -66,30 +71,32 @@ namespace boost {
 
         //! Find all algorithm ( case insensitive ) 
         /*!
-            This algorithm finds all occurrences of the search sequence
-            in the input. A result is given as a 'container of containers'.
-            Each match of the search sequence is represented by one
-            element in the result. Searching is case insensitive.
+            This algorithm finds all occurrences of the search string
+            in the input. 
+            Each part is copied and added as a new element to the
+            output container. Thus the result container must be able to hold copies
+            of the matches (in a compatible structure like std::string) or
+            a reference to it (e.g. using the iterator range class).
+            Examples of such a container are \c std::vector<std::string>
+            or \c std::list<boost::iterator_range<std::string::iterator>>
 
-            \param Result A 'container container' to container the result of search.
-                Both outer and inner container must have constructor taking a pair
-                of iterators as an argument.
-                Typical type of the result is 
-                    \c std::vector<boost::iterator_range<iterator>>.
-                (each element of such a vector will container a range delimiting 
-                a match).
+            Searching is case insensitive.
+
+            \param Result A container that can hold copies of references to the substrings
             \param Input A container which will be searched.
-            \param Search A string to be searched for.
-            \param Loc a locale used for case insensitive comparison
+            \param Search A substring to be searched for.
+            \param Loc A locale used for case insensitive comparison
             \return A reference the result
 
-            \note Prior content of the result will be overridden.
+            \note Prior content of the result will be overwritten.
+
+              \note This function provides the strong exception-safety guarantee
         */
-        template< typename SequenceSequenceT, typename Collection1T, typename Collection2T >
+        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
         inline SequenceSequenceT& ifind_all(
             SequenceSequenceT& Result,
-            Collection1T& Input,
-            const Collection2T& Search,
+            Range1T& Input,
+            const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
             return iter_find(
@@ -103,18 +110,19 @@ namespace boost {
 
         //! Split algorithm
         /*! 
-            Tokenize expression. This function is equivalent of C strtok. Input
+            Tokenize expression. This function is equivalent to C strtok. Input
             sequence is split into tokens, separated by separators. Separators 
-            are given in the mean of predicate.
-
-            \param Result A 'container container' to container the result of search.
-                Both outer and inner container must have constructor taking a pair
-                of iterators as an argument.
-                Typical type of the result is 
-                    \c std::vector<boost::iterator_range<iterator>>.
-                (each element of such a vector will container a range delimiting 
-                a match).
+            are given by means of the predicate.
 
+            Each part is copied and added as a new element to the
+            output container.
+            Thus the result container must be able to hold copies
+            of the matches (in a compatible structure like std::string) or
+            a reference to it (e.g. using the iterator range class).
+            Examples of such a container are \c std::vector<std::string>
+            or \c std::list<boost::iterator_range<std::string::iterator>>
+    
+            \param Result A container that can hold copies of references to the substrings          
             \param Input A container which will be searched.
             \param Pred A predicate to identify separators. This predicate is 
                 supposed to return true if a given element is a separator.
@@ -123,12 +131,14 @@ namespace boost {
                 delimit a token.
             \return A reference the result
 
-            \note Prior content of the result will be overridden.
+            \note Prior content of the result will be overwritten.
+
+            \note This function provides the strong exception-safety guarantee
         */
-        template< typename SequenceSequenceT, typename CollectionT, typename PredicateT >
+        template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
         inline SequenceSequenceT& split(
             SequenceSequenceT& Result,
-            CollectionT& Input,
+            RangeT& Input,
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off )
         {

include/boost/algorithm/string/std/list_traits.hpp

@@ -33,38 +33,50 @@ namespace boost {
         template<typename T, typename AllocT>
         yes_type has_const_time_erase_tester( const ::std::list<T,AllocT>* );
 
-        
+
 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-        
-    // stable iterators trait
+
+        // stable iterators trait
         template<typename T, typename AllocT>
         class has_stable_iterators< ::std::list<T,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
-            typedef mpl::bool_<value> type;     
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_stable_iterators<T>::value> type;
         };
 
-    // const time insert trait
+        // const time insert trait
         template<typename T, typename AllocT>
         class has_const_time_insert< ::std::list<T,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
-            typedef mpl::bool_<value> type;     
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_const_time_insert<T>::value> type;
         };
 
-    // const time erase trait
+        // const time erase trait
         template<typename T, typename AllocT>
         class has_const_time_erase< ::std::list<T,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
-            typedef mpl::bool_<value> type;     
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_const_time_erase<T>::value> type;
         };
 #endif
 
-        
+
     } // namespace algorithm
 } // namespace boost
 

include/boost/algorithm/string/std/rope_traits.hpp

@@ -43,8 +43,12 @@ namespace boost {
         template<typename T, typename TraitsT, typename AllocT>
         class has_native_replace< std::rope<T,TraitsT,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
             typedef mpl::bool_<value> type;     
         };
 
@@ -52,8 +56,12 @@ namespace boost {
         template<typename T, typename TraitsT, typename AllocT>
         class has_stable_iterators< std::rope<T,TraitsT,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
             typedef mpl::bool_<value> type;     
         };
 
@@ -61,8 +69,12 @@ namespace boost {
         template<typename T, typename TraitsT, typename AllocT>
         class has_const_time_insert< std::rope<T,TraitsT,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
             typedef mpl::bool_<value> type;     
         };
 
@@ -70,8 +82,12 @@ namespace boost {
         template<typename T, typename TraitsT, typename AllocT>
         class has_const_time_erase< std::rope<T,TraitsT,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
             typedef mpl::bool_<value> type;     
         };
 #endif

include/boost/algorithm/string/std/slist_traits.hpp

@@ -10,6 +10,7 @@
 #ifndef BOOST_STRING_STD_SLIST_TRAITS_HPP
 #define BOOST_STRING_STD_SLIST_TRAITS_HPP
 
+#include <boost/algorithm/string/config.hpp>
 #include <boost/algorithm/string/yes_no_type.hpp>
 #include <slist>
 #include <boost/algorithm/string/sequence_traits.hpp>
@@ -23,43 +24,55 @@ namespace boost {
 
         // stable iterators tester
         template<typename T, typename AllocT>
-        yes_type has_stable_iterators_tester( const std::slist<T,AllocT>* );
+        yes_type has_stable_iterators_tester( const BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT>* );
 
         // const time insert tester
         template<typename T, typename AllocT>
-        yes_type has_const_time_insert_tester( const std::slist<T,AllocT>* );
+        yes_type has_const_time_insert_tester( const BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT>* );
 
         // const time erase tester
         template<typename T, typename AllocT>
-        yes_type has_const_time_erase_tester( const std::slist<T,AllocT>* );
+        yes_type has_const_time_erase_tester( const BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT>* );
 
 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    
+
     // stable iterators trait
         template<typename T, typename AllocT>
-        class has_stable_iterators< std::slist<T,AllocT> >
+        class has_stable_iterators< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
-            typedef mpl::bool_<value> type;     
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_stable_iterators<T>::value> type;
         };
 
     // const time insert trait
         template<typename T, typename AllocT>
-        class has_const_time_insert< std::slist<T,AllocT> >
+        class has_const_time_insert< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
-            typedef mpl::bool_<value> type;     
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_const_time_insert<T>::value> type;
         };
 
     // const time erase trait
         template<typename T, typename AllocT>
-        class has_const_time_erase< std::slist<T,AllocT> >
+        class has_const_time_erase< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
-            typedef mpl::bool_<value> type;     
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_const_time_erase<T>::value> type;
         };
 #endif
 

include/boost/algorithm/string/std/string_traits.hpp

@@ -31,9 +31,14 @@ namespace boost {
         template<typename T, typename TraitsT, typename AllocT>
         class has_native_replace< std::basic_string<T, TraitsT, AllocT> >
         {
-           public:
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true } ;
+#else
             BOOST_STATIC_CONSTANT(bool, value=true);
-            typedef mpl::bool_<value> type;     
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+
+        typedef mpl::bool_<has_native_replace<T>::value> type;
         };
 
 

include/boost/algorithm/string/trim.hpp

@@ -11,7 +11,11 @@
 #define BOOST_STRING_TRIM_HPP
 
 #include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/collection_traits.hpp>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/const_iterator.hpp>
+
 #include <boost/algorithm/string/detail/trim.hpp>
 #include <boost/algorithm/string/classification.hpp>
 #include <locale>
@@ -21,10 +25,10 @@
     Trim algorithms are used to remove trailing and leading spaces from a 
     sequence (string). Space is recognized using given locales.
 
-    Parametric (\c _if) variants use predicate (functor) to select which characters
+    Parametric (\c _if) variants use a predicate (functor) to select which characters
     are to be trimmed.. 
     Functions take a selection predicate as a parameter, which is used to determine 
-    if a character is a space. Common predicates are provided in classification.hpp header.
+    whether a character is a space. Common predicates are provided in classification.hpp header.
 
 */
 
@@ -36,23 +40,28 @@ namespace boost {
 
         //! Left trim - parametric
         /*!
-            Remove all leading spaces from the input. Supplied predicate
-            is used to determine which character is a space.
-            The result is copied to the given output iterator.
+            Remove all leading spaces from the input. 
+            The supplied predicate is used to determine which characters are considered spaces.
+            The result is a trimmed copy of the input. It is returned as a sequence 
+            or copied to the output iterator
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input collection
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
             \param IsSpace An unary predicate identifying spaces
-            \return An output iterator pointing just after last inserted character
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+               \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
         inline OutputIteratorT trim_left_copy_if( 
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             PredicateT IsSpace)
         {
             std::copy( 
-                detail::trim_begin( 
+                ::boost::algorithm::detail::trim_begin( 
                     begin(Input), 
                     end(Input), 
                     IsSpace ),
@@ -64,19 +73,13 @@ namespace boost {
 
         //! Left trim - parametric
         /*!
-            Remove all leading spaces from the input. Supplied predicate
-            is used to determine which character is a space.
-            The result is a trimmed copy if the input
-
-            \param Input An input sequence
-            \param IsSpace An unary predicate identifying spaces
-            \return A trimmed copy if the input
+            \overload
         */
         template<typename SequenceT, typename PredicateT>
         inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace)
         {
             return SequenceT( 
-                detail::trim_begin( 
+                ::boost::algorithm::detail::trim_begin( 
                     begin(Input), 
                     end(Input), 
                     IsSpace ),
@@ -86,11 +89,13 @@ namespace boost {
         //! Left trim - parametric
         /*!
             Remove all leading spaces from the input. 
-            The result is a trimmed copy if the input
+            The result is a trimmed copy of the input.
 
             \param Input An input sequence
             \param Loc a locale used for 'space' classification
-            \return A trimmed copy if the input
+            \return A trimmed copy of the input
+
+            \note This function provides the strong exception-safety guarantee
         */
         template<typename SequenceT>
         inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
@@ -103,8 +108,8 @@ namespace boost {
 
         //! Left trim
         /*!
-            Remove all leading spaces from the input. Supplied predicate
-            is used to determine which character is a space.
+            Remove all leading spaces from the input. The supplied predicate is 
+            used to determine which characters are considered spaces.
             The input sequence is modified in-place.
 
             \param Input An input sequence
@@ -115,7 +120,7 @@ namespace boost {
         {
             Input.erase( 
                 begin(Input),
-                detail::trim_begin( 
+                ::boost::algorithm::detail::trim_begin( 
                     begin(Input), 
                     end(Input), 
                     IsSpace));
@@ -141,24 +146,29 @@ namespace boost {
 
         //! Right trim - parametric
         /*!
-            Remove all trailing spaces from the input. Supplied predicate
-            is used to determine which character is a space.
-            The result is copied to the given output iterator.
+            Remove all trailing spaces from the input.             
+            The supplied predicate is used to determine which characters are considered spaces.
+            The result is a trimmed copy of the input. It is returned as a sequence 
+            or copied to the output iterator
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input collection
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
             \param IsSpace An unary predicate identifying spaces
-            \return An output iterator pointing just after last inserted character
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
         inline OutputIteratorT trim_right_copy_if( 
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             PredicateT IsSpace )
         {
             std::copy( 
                 begin(Input),
-                detail::trim_end( 
+                ::boost::algorithm::detail::trim_end( 
                     begin(Input), 
                     end(Input), 
                     IsSpace ),
@@ -169,20 +179,14 @@ namespace boost {
 
         //! Right trim - parametric
         /*!
-            Remove all trailing spaces from the input. Supplied predicate
-            is used to determine which character is a space.
-            The result is a trimmed copy if the input
-
-            \param Input An input Sequence
-            \param IsSpace An unary predicate identifying spaces
-            \return A trimmed copy if the input
-        */
+            \overload
+         */
         template<typename SequenceT, typename PredicateT>
         inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
         {
             return SequenceT( 
                 begin(Input),
-                detail::trim_end( 
+                ::boost::algorithm::detail::trim_end( 
                     begin(Input), 
                     end(Input), 
                     IsSpace)
@@ -192,12 +196,14 @@ namespace boost {
         //! Right trim
         /*!
             Remove all trailing spaces from the input. 
-            The result is a trimmed copy if the input
+            The result is a trimmed copy of the input
 
             \param Input An input sequence
             \param Loc A locale used for 'space' classification
-            \return A trimmed copy if the input
-        */  
+            \return A trimmed copy of the input
+
+            \note This function provides the strong exception-safety guarantee
+        */
         template<typename SequenceT>
         inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
         {
@@ -210,8 +216,8 @@ namespace boost {
             
         //! Right trim - parametric
         /*!
-            Remove all trailing spaces from the input. Supplied predicate
-            is used to determine which character is a space.
+            Remove all trailing spaces from the input.
+            The supplied predicate is used to determine which characters are considered spaces.
             The input sequence is modified in-place.
 
             \param Input An input sequence
@@ -221,7 +227,7 @@ namespace boost {
         inline void trim_right_if(SequenceT& Input, PredicateT IsSpace)
         {
             Input.erase(
-                detail::trim_end( 
+                ::boost::algorithm::detail::trim_end( 
                     begin(Input), 
                     end(Input), 
                     IsSpace ),
@@ -251,23 +257,28 @@ namespace boost {
         //! Trim - parametric
         /*!
             Remove all trailing and leading spaces from the input. 
-            Supplied predicate is used to determine which character is a space.
-            The result is copied to the given output iterator.
+            The supplied predicate is used to determine which characters are considered spaces.
+            The result is a trimmed copy of the input. It is returned as a sequence 
+            or copied to the output iterator
 
-            \param Output A output iterator to which the result will be copied
-            \param Input An input collection
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
             \param IsSpace An unary predicate identifying spaces
-            \return An output iterator pointing just after last inserted character
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
         inline OutputIteratorT trim_copy_if( 
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             PredicateT IsSpace)
         {
             BOOST_STRING_TYPENAME 
-                const_iterator_of<CollectionT>::type TrimEnd=
-                detail::trim_end( 
+                range_const_iterator<RangeT>::type TrimEnd=
+                ::boost::algorithm::detail::trim_end( 
                     begin(Input), 
                     end(Input), 
                     IsSpace);
@@ -284,20 +295,14 @@ namespace boost {
 
         //! Trim - parametric
         /*!
-            Remove all leading and trailing spaces from the input. 
-            Supplied predicate is used to determine which character is a space.
-            The result is a trimmed copy if the input
-
-            \param Input An input sequence
-            \param IsSpace An unary predicate identifying spaces
-            \return A trimmed copy if the input
-        */
+            \overload
+         */
         template<typename SequenceT, typename PredicateT>
         inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace)
         {
             BOOST_STRING_TYPENAME 
-                const_iterator_of<SequenceT>::type TrimEnd=
-                    detail::trim_end( 
+                range_const_iterator<SequenceT>::type TrimEnd=
+                    ::boost::algorithm::detail::trim_end( 
                         begin(Input), 
                         end(Input), 
                         IsSpace);
@@ -314,11 +319,13 @@ namespace boost {
         //! Trim
         /*!
             Remove all leading and trailing spaces from the input. 
-            The result is a trimmed copy if the input
+            The result is a trimmed copy of the input
 
             \param Input An input sequence
             \param Loc A locale used for 'space' classification
-            \return A trimmed copy if the input
+            \return A trimmed copy of the input
+
+            \note This function provides the strong exception-safety guarantee
         */
         template<typename SequenceT>
         inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
@@ -332,7 +339,7 @@ namespace boost {
         //! Trim
         /*!
             Remove all leading and trailing spaces from the input. 
-            Supplied predicate is used to determine which character is a space.
+            The supplied predicate is used to determine which characters are considered spaces.
             The input sequence is modified in-place.
 
             \param Input An input sequence

include/boost/algorithm/string/yes_no_type.hpp

@@ -14,7 +14,7 @@ namespace boost {
     namespace algorithm {
 
         // taken from boost mailing-list
-        // when yes_no_type will become officialy
+        // when yes_no_type will become officially
         // a part of boost distribution, this header
         // will be deprecated
         template<int I> struct size_descriptor 

include/boost/algorithm/string_regex.hpp

@@ -1,9 +1,9 @@
-//  Boost string_algo library string_algo.hpp header file  ---------------------------//
+//  Boost string_algo library string_regex.hpp header file  ---------------------------//
 
-//  (C) Copyright Pavol Droba 2002-2003. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+//  Copyright Pavol Droba 2002-2004. Use, modification and
+//  distribution is subject to 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 for updates, documentation, and revision history.
 
@@ -12,11 +12,11 @@
 
 /*! \file
     Cumulative include for string_algo library.
-    In addtion to string_algo.hpp, it contains also regex-related stuff.
+    In addtion to string.hpp contains also regex-related stuff.
 */
 
 #include <boost/regex.hpp>
-#include <boost/string_algo.hpp>
+#include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/regex.hpp>
 
 #endif  // BOOST_STRING_ALGO_REGEX_HPP

include/boost/minmax.hpp

@@ -1,52 +0,0 @@
-//  (C) Copyright Eric Niebler 2004.
-//  Use, modification and distribution are subject to 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)
-
-/*
- Revision history:
-   25 February 2004
-      Initial version.
-*/
-
-#ifndef BOOST_MINMAX_HPP
-#define BOOST_MINMAX_HPP
-
-#include <algorithm> // for std::min and std::max
-#include <boost/config.hpp>
-
-namespace boost
-{
-
-template< typename T >
-inline T const & std_min( T const & a, T const & b )
-{
-    using std::min;
-
-    return min BOOST_PREVENT_MACRO_SUBSTITUTION ( a, b );
-}
-
-template< typename T >
-inline T const & std_max( T const & a, T const & b )
-{
-    using std::max;
-
-    return max BOOST_PREVENT_MACRO_SUBSTITUTION ( a, b );
-}
-
-// Overloads for unsigned long to work around a bug in the Borland headers
-#ifdef __BORLANDC__
-inline unsigned long const & std_min( unsigned long const & a, unsigned long const & b )
-{
-    return a < b ? a : b;
-}
-
-inline unsigned long const & std_max( unsigned long const & a, unsigned long const & b )
-{
-    return a > b ? a : b;
-}
-#endif
-
-}
-
-#endif // BOOST_MINMAX_HPP

string/doc/Jamfile.v2

@@ -1,61 +0,0 @@
-#  Boost string_algo library documentation Jamfile  ---------------------------------
-#
-#  Copyright Pavol Droba 2002-2003. Use, modification and
-#  distribution is subject to the Boost Software License, Version
-#  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-#  htt../..//www.boost.org/LICENSE_1_0.txt)
-#
-#  See htt../..//www.boost.org for updates, documentation, and revision history.
-
-project boost/libs/algorithm/string/doc ;
-
-doxygen reference 
-    :   
-    ../../../../boost/algorithm/string.hpp
-    ../../../../boost/algorithm/string_regex.hpp
-
-    ../../../../boost/algorithm/string/classification.hpp
-    ../../../../boost/algorithm/string/iterator_range.hpp         
-    ../../../../boost/algorithm/string/sequence_traits.hpp
-    ../../../../boost/algorithm/string/std_containers_traits.hpp
-    ../../../../boost/algorithm/string/container_traits.hpp
-    ../../../../boost/algorithm/string/concept.hpp
-    ../../../../boost/algorithm/string/compare.hpp
-    ../../../../boost/algorithm/string/constants.hpp
-
-    ../../../../boost/algorithm/string/case_conv.hpp 
-
-    ../../../../boost/algorithm/string/find.hpp 
-    ../../../../boost/algorithm/string/finder.hpp
-    ../../../../boost/algorithm/string/find_iterator.hpp
-
-    ../../../../boost/algorithm/string/trim.hpp
-
-    ../../../../boost/algorithm/string/predicate.hpp
-    ../../../../boost/algorithm/string/split.hpp
-    ../../../../boost/algorithm/string/iter_find.hpp
-
-    ../../../../boost/algorithm/string/erase.hpp
-    ../../../../boost/algorithm/string/replace.hpp
-    ../../../../boost/algorithm/string/find_format.hpp
-    ../../../../boost/algorithm/string/formatter.hpp
-
-    ../../../../boost/algorithm/string/regex.hpp
-    ../../../../boost/algorithm/string/regex_find_format.hpp
-    :
-    <doxygen:param>HIDE_UNDOC_MEMBERS=YES
-    <doxygen:param>EXTRACT_PRIVATE=NO
-    <doxygen:param>ENABLE_PREPROCESSING=YES
-    <doxygen:param>MACRO_EXPANSION=YES
-    <doxygen:param>EXPAND_ONLY_PREDEF=YES
-    <doxygen:param>SEARCH_INCLUDES=YES
-    <doxygen:param>PREDEFINED="BOOST_STRING_TYPENAME=typename \"BOOST_STATIC_CONSTANT(type,var)=static const type var;\""
-    ;
-        
-boostbook string_algo 
-    : 
-    string_algo.xml 
-    ;
-
-
-

string/doc/concept.xml

@@ -1,199 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<section id="string_algo.concept" last-revision="$Date$">
-    <title>Concepts</title>
-
-    <using-namespace name="boost"/>
-    <using-namespace name="boost::string_algo"/>
-
-    <section>   
-        <title>Definitions</title>
-        
-        <table>
-            <title>Notation</title>
-            <tgroup cols="2" align="left">
-                <tbody>
-                    <row>
-                        <entry><code>F</code></entry>
-                        <entry>A type that is a model of Finder</entry>
-                    </row>
-                    <row>
-                        <entry><code>Fmt</code></entry>
-                        <entry>A type that is a model of Formatter</entry>
-                    </row>
-                    <row>
-                        <entry><code>Iter</code></entry>
-                        <entry>
-                            Iterator Type
-                        </entry>
-                    </row>
-                    <row>
-                        <entry><code>f</code></entry>
-                        <entry>Object of type <code>F</code></entry>
-                    </row>
-                    <row>
-                        <entry><code>fmt</code></entry>
-                        <entry>Object of type <code>Fmt</code></entry>
-                    </row>
-                    <row>
-                        <entry><code>i,j</code></entry>
-                        <entry>Objects of type <code>Iter</code></entry>
-                    </row>
-                    </tbody>
-            </tgroup>
-        </table>
-    </section>
-
-    <section id="string_algo.finder_concept">
-        <title>Finder Concept</title>
-
-        <para>
-            Finder is a functor which searches for an arbitrary part of a container. 
-            The result of the search is given as an <classname>iterator_range</classname> 
-            delimiting the selected part.
-        </para>
-
-        <table>             
-            <title>Valid Expressions</title>
-            <tgroup cols="3" align="left">
-                <thead>
-                    <row>   
-                        <entry>Expression</entry>
-                        <entry>Return Type</entry>
-                        <entry>Effects</entry>
-                    </row>
-                </thead>
-                <tbody>
-                    <row>
-                        <entry><code>f(i,j)</code></entry>
-                        <entry>Convertible to <code>iterator_range&lt;Iter&gt;</code></entry>
-                        <entry>Perform the search on the interval [i,j) and returns the result of the search</entry>
-                    </row>
-                </tbody>
-            </tgroup>
-        </table>
-
-        <para>
-            Various algorithms need to perform a searching in a container and a Finder is a generalization of such
-            search operations that allows algorithms to abstract from searching. For instance, generic replace
-            algorithms can replace any part of the input, and the finder is used to select the desired one.
-        </para>
-        <para>
-            Note, that it is only required that the finder works with a particular iterator type. However,
-            a Finder operation can be defined as a template, allowing the Finder to work with any iterator.
-        </para>
-        <para>
-            <emphasis role="bold">Examples</emphasis>
-        </para>
-        <para> 
-            <itemizedlist>
-                <listitem>
-                    Finder implemented as a class. This Finder always returns the whole input as a match. <code>operator()</code>
-                    is templated, so that the finder can be used on any iterator type.
-                    
-                    <programlisting>
-struct simple_finder
-{
-    template&lt;typename ForwardIteratorT&gt;
-    boost::iterator_range&lt;ForwardIterator&gt; operator()(
-        ForwardIteratorT Begin,
-        ForwardIteratorT End )
-    {
-        return boost::make_range( Begin, End );
-    }
-};
-        </programlisting>
-                </listitem>
-                <listitem>
-                    Function Finder. Finder can be any function object. That means, an ordinary function with the
-                    required signature can be used as well. However, such a function can be used only for
-                    a specific iterator type. 
-                    
-                    <programlisting>
-boost::iterator_range&lt;std::string&gt; simple_finder(
-    std::string::const_iterator Begin,
-    std::string::const_iterator End )
-{
-    return boost::make_range( Begin, End );
-}
-        </programlisting>
-                </listitem>
-            </itemizedlist>
-        </para> 
-    </section>
-    <section id="string_algo.formatter_concept">
-        <title>Formatter concept</title>
-
-        <para>
-            Formatters are used by <link linkend="string_algo.replace">replace algorithms</link>.
-            They are used in close combination with finders.
-            A formatter is a functor, which takes a result from a Finder operation and transforms it in a specific way. 
-            The operation of the formatter can use additional information provided by a specific finder,
-            for example <functionname>regex_formatter()</functionname> uses the match information from
-            <functionname>regex_finder()</functionname> to format the result of formatter operation.
-        </para>
-    
-        <table>
-            <title>Valid Expressions</title>
-            <tgroup cols="3" align="left">
-                <thead>
-                    <row>   
-                        <entry>Expression</entry>
-                        <entry>Return Type</entry>
-                        <entry>Effects</entry>
-                    </row>
-                </thead>
-                <tbody>
-                   <row>
-                        <entry><code>fmt(f(i,j))</code></entry>
-                        <entry>A container type, accessible using container traits</entry>
-                        <entry>Formats the result of the finder operation</entry>
-                    </row>
-                </tbody>
-            </tgroup>
-        </table>
-
-        <para>
-            Similarly to finders, formatters generalize format operations. When a finder is used to 
-            select a part of the input, formatter takes this selection and performs some formating
-            on it. Algorithms can abstract from formating using a formatter.
-        </para>
-        <para>
-            <emphasis role="bold">Examples</emphasis>
-        </para>
-        <para> 
-            <itemizedlist>
-                <listitem>
-                    Formatter implemented as a class. This Formatter does not perform any formating and 
-                    returns repackaged match. <code>operator()</code>
-                    is templated, so that the Formatter can be used on any Finder type.
-                    
-                    <programlisting>
-struct simple_formatter
-{
-    template&lt;typename FindResultT&gt;
-    std::string operator()( const FindResultT&amp; Match )
-    {
-        std::string Temp( Match.begin(), Match.end() );
-        return Temp;
-    }
-};
-                </programlisting>
-                </listitem>
-                <listitem>
-                    Function Formatter. Similarly to Finder, Formatter can be any function object. 
-                    However, as a function, it can be used only with a specific Finder type. 
-                  
-                    <programlisting>
-std::string simple_formatter( boost::iterator_range&lt;std::string::const_iterator&gt;&amp; Match )
-{
-    std::string Temp( Match.begin(), Match.end() );
-    return Temp;
-}
-                    </programlisting>
-                </listitem>
-            </itemizedlist>
-        </para> 
-     </section>
-</section>

string/doc/credits.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<section id="string_algo.credits" last-revision="$Date$">
-    <title>Credits</title>
-    <section id="string_algo.ack">
-        <title>Acknowledgments</title>
-        <para>
-            Thanks for everybody who gave suggestions and comments. Especially to Thorsten Ottosen, Jeff Garland
-            and the other boost members who participated.
-        </para>
-    </section>
-</section>

string/doc/design.xml

@@ -1,281 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<section id="string_algo.design" last-revision="$Date$">
-    <title>Design Topics</title>
-
-    <using-namespace name="boost"/>
-    <using-namespace name="boost::string_algo"/>
-    
-    <section id="string_algo.iterator_range">
-        <title><code>iterator_range</code> class</title>
-
-        <para>
-            An <classname>iterator_range</classname> is an encapsulation of a pair of iterators that
-            delimit a sequence (or, a range). This concept is widely used by 
-            sequence manipulating algorithms. Although being so useful, there no direct support 
-            for it in the standard library (The closest thing is that some algorithms return a pair of iterators). 
-            Instead all STL algorithms have two distinct parameters for beginning and end of a range. This design 
-            is natural for implementation of generic algorithms, but it forbids to work with a range as a single value. 
-        </para> 
-        <para>
-            It is possible to encapsulate a range in <code>std::pair&lt;&gt;</code>, but
-            the <code>std::pair&lt;&gt;</code> is a too generic encapsulation, so it is not best match for a range.
-            For instance, it does not enforce that begin and end iterators are of the same type.
-        </para>
-        <para>
-            Naturally the range concept is heavily used also in this library. During the development of
-            the library, it was discovered, that there is a need for a reasonable encapsulation for it.
-            A core part of the library deals with substring searching algorithms. Any such an algorithm,
-            returns a range delimiting the result of the search. <code>std::pair&lt;&gt;</code> was considered as 
-            unsuitable. Therefore the <code>iterator_range</code> was defined.
-        </para>
-        <para>
-            The intention of the <code>iterator_range</code> class is to manage a range as a single value and provide 
-            a basic interface for common operations. Its interface is similar to that of container. 
-            In addition of <code>begin()</code>
-            and <code>end()</code> accessors, it has member functions for checking if the range is empty,
-            or to determine the size of the range. It has also a set of member typedefs that extract
-            type information from the encapsulated iterators. As such, the interface is compatible with 
-            the <link linkend="string_algo.container_traits">container traits</link> requirements so
-            it is possible to use this class as a parameter to many algorithms in this library.
-        </para>
-    </section>
-        
-    <section id="string_algo.container_traits">
-        <title>Container Traits</title>
-
-        <para>
-            Container traits provide uniform access to different types of containers. 
-            This functionality allows to write generic algorithms which work with several 
-            different kinds of containers. For this library it means, that, for instance,
-            many algorithms work with <code>std::string</code> as well as with <code>char[]</code>.
-        </para>
-        <para>
-            The following container types are supported:
-            <itemizedlist>
-                <listitem>
-                    Standard containers
-                </listitem>
-                <listitem>
-                    Built-in arrays (like int[])
-                </listitem>
-                <listitem>
-                    Null terminated strings (this includes char[],wchar_t[],char*, and wchar_t*)
-                </listitem>
-                <listitem>
-                    std::pair&lt;iterator,iterator&gt;
-                </listitem>
-            </itemizedlist>
-        </para>
-        <para>
-            Container traits support a subset of container concept (Std &sect;23.1). This subset 
-            can be described as an input container concept, e.g. a container with an immutable content. 
-            Its definition can be found in the header <headername>boost/string_algo/container_traits.hpp</headername>.
-        </para>
-        <para>
-            In the table C denotes a container and c is an object of C. 
-        </para>
-        <table>
-            <title>Container Traits</title>
-            <tgroup cols="3" align="left">
-                <thead>
-                    <row>   
-                        <entry>Name</entry>
-                        <entry>Standard container equivalent</entry>
-                        <entry>Description</entry>
-                    </row>Maeterlinck
-                </thead>
-                <tbody>
-                    <row>
-                        <entry><classname>container_value_type&lt;C&gt;</classname>::type</entry>
-                        <entry><code>C::value_type</code></entry>
-                        <entry>Type of contained values</entry>
-                    </row>
-                    <row>
-                        <entry><classname>container_difference_type&lt;C&gt;</classname>::type</entry>
-                        <entry><code>C::difference_type</code></entry>
-                        <entry>difference type of the container</entry>
-                    </row>
-                    <row>
-                        <entry><classname>container_iterator&lt;C&gt;</classname>::type</entry>
-                        <entry><code>C::iterator</code></entry>
-                        <entry>iterator type of the container</entry>
-                    </row>
-                    <row>
-                        <entry><classname>container_const_iterator&lt;C&gt;</classname>::type</entry>
-                        <entry><code>C::const_iterator</code></entry>
-                        <entry>const_iterator type of the container</entry>
-                    </row>
-                    <row>
-                        <entry><classname>container_result_iterator&lt;C&gt;</classname>::type</entry>
-                        <entry></entry>
-                        <entry>
-                            result_iterator type of the container. This type maps to <code>C::iterator</code>
-                            for mutable container and <code>C::const_iterator</code> for const containers.
-                        </entry>
-                    </row>
-                    <row>
-                        <entry><functionname>begin(c)</functionname></entry>
-                        <entry><code>c.begin()</code></entry>
-                        <entry>
-                            Gets the iterator pointing to the start of the container.
-                        </entry>
-                    </row>
-                    <row>
-                        <entry><functionname>end(c)</functionname></entry>
-                        <entry><code>c.end()</code></entry>
-                        <entry>
-                            Gets the iterator pointing to the end of the container.
-                        </entry>
-                    </row>
-                    <row>
-                        <entry><functionname>size(c)</functionname></entry>
-                        <entry><code>c.size()</code></entry>
-                        <entry>
-                            Gets the size of the container.
-                        </entry>
-                    </row>
-                    <row>
-                        <entry><functionname>empty(c)</functionname></entry>
-                        <entry><code>c.empty()</code></entry>
-                        <entry>
-                            Checks if the container is empty.
-                        </entry>
-                    </row>
-                </tbody>
-            </tgroup>
-        </table>
-
-        <para>
-            The container traits are only a temporary part of this library. There is a plan for a separate submission
-            of a container_traits library to Boost. Once it gets accepted, String Algorithm Library will be adopted to 
-            use it and the internal implementation will be deprecated.
-        </para>
-    
-    </section>
-    <section id="string_algo.sequence_traits">
-        <title>Sequence Traits</title>
-
-        <para>
-            Major difference between <code>std::list</code> and <code>std::vector</code> is not in the interfaces
-            they provide, rather in the inner details of the class and the way how it performs 
-            various operation. The problem is that it is not possible to infer this difference from the 
-            definitions of classes without some special mechanism.
-            However some algorithms can run significantly faster with the knowledge of the properties
-            of a particular container.
-        </para>
-        <para>
-            Sequence traits allows one to specify additional properties of a sequence container (see Std.&sect;32.2).
-            These properties are then used by algorithms to select optimized handling for some operations.
-            The sequence traits are declared in the header 
-            <headername>boost/string_algo/sequence_traits.hpp</headername>.
-        </para>
-
-        <para>
-            In the table C denotes a container and c is an object of C.
-        </para>
-        <table>
-            <title>Sequence Traits</title>
-            <tgroup cols="2" align="left">
-                <thead>
-                    <row>   
-                        <entry>Trait</entry>
-                        <entry>Description</entry>
-                    </row>
-                </thead>
-                <tbody>
-                    <row>
-                        <entry><classname>sequence_has_native_replace&lt;C&gt;</classname>::value</entry>
-                        <entry>Specifies that the sequence has std::string like replace method</entry>
-                    </row>
-                    <row>
-                        <entry><classname>sequence_has_stable_iterators&lt;C&gt;</classname>::value</entry>
-                        <entry>
-                            Specifies that the sequence has stable iterators. It means,
-                            that operations like <code>insert</code>/<code>erase</code>/<code>replace</code> 
-                            do not invalidate iterators.
-                        </entry>
-                    </row>
-                    <row>
-                        <entry><classname>sequence_has_const_time_insert&lt;C&gt;</classname>::value</entry>
-                        <entry>
-                            Specifies that the insert method of the sequence has 
-                            constant time complexity.
-                        </entry>
-                    </row>
-                    <row>
-                        <entry><classname>sequence_has_const_time_erase&lt;C&gt;</classname>::value</entry>
-                        <entry>
-                            Specifies that the erase method of the sequence has constant time complexity
-                        </entry>
-                    </row>
-                    </tbody>
-            </tgroup>
-        </table>
-        
-        <para>
-            Current implementation contains specializations for std::list&lt;T&gt; and
-            std::basic_string&lt;T&gt; from the standard library and SGI's std::rope&lt;T&gt; and std::slist&lt;T&gt;.
-        </para>
-    </section>
-    <section id="string_algo.find">
-        <title>Find Algorithms</title>
-
-        <para>
-            Find algorithms have similar functionality to <code>std::search()</code> algorithm. They provide a different 
-            interface which is more suitable for common string operations. 
-            Instead of returning just the start of matching subsequence they return a range which is necessary 
-            when the length of the matching subsequence is not known beforehand. 
-            This feature also allows a partitioning of  the input sequence into three 
-            parts: a prefix, a substring and a suffix. 
-        </para>
-        <para>
-            Another difference is an addition of various searching methods besides find_first, including find_regex. 
-        </para>
-        <para>
-            It the library, find algorithms are implemented in terms of 
-            <link linkend="string_algo.finder_concept">Finders</link>. Finders are used also by other facilities 
-            (replace,split).
-            For convenience, there are also function wrappers for these finders to simplify find operations.
-        </para>
-        <para>
-            Currently the library contains only naive implementation of find algorithms with complexity 
-            O(n * m) where n is the size of the input sequence and m is the size of the search sequence. 
-            There are algorithms with complexity O(n), but for smaller sequence a constant overhead is 
-            rather big. For small m &lt;&lt; n (m magnitued smaller than n) the current implementation 
-            provides acceptable efficiency. 
-            Even the C++ standard defines the required complexity for search algorithm as O(n * m). 
-            It is possible that a future version of library will also contain algorithms with linear 
-            complexity as an option
-        </para>
-    </section>
-    <section id="string_algo.replace">
-        <title>Replace Algorithms</title>
-
-        <para>
-            The implementation of replace algorithms follows the layered structure of the library. The 
-            lower layer implements generic substitution of a range in the input sequence. 
-            This layer takes a <link linkend="string_algo.finder_concept">Finder</link> object and a 
-            <link linkend="string_algo.formatter_concept">Formatter</link> object as an input. These two 
-            functors define what to replace and what to replace it with. The upper layer functions 
-            are just wrapping calls to the lower layer. Finders are shared with the find and split facility. 
-        </para>
-        <para>
-            As usual, the implementation of the lower layer is designed to work with a generic sequence while
-            taking an advantage of specific features if possible 
-            (by using <link linkend="string_algo.sequence_traits">Sequence traits</link>)
-        </para>         
-    </section>
-    <section id="string_algo.split">
-        <title>Split Algorithms</title>
-
-        <para>
-            Split algorithms are a logical extension of <link linkend="string_algo.find">find facility</link>.
-            Instead of searching for one match, the whole input is searched. The result of the search is then used 
-            to partition the input. It depends on the algorithms which parts are returned as the result of
-            split operations. It can be the matching parts (<functionname>find_all()</functionname>) of the parts in
-            between (<functionname>split()</functionname>). 
-        </para>
-    </section>
-</section>

string/doc/environment.xml

@@ -1,55 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<section id="string_algo.env" last-revision="$Date$">
-    <title>Environment</title>
-    <section>
-        <title>Build</title>
-        <para>
-            The whole library is provided in headers. Regex variants of some algorithms, 
-            however, are dependent on the <libraryname>Boost.Regex</libraryname> library. All such algorithms are
-            separated in <headername>boost/string_algo/regex.hpp</headername>. 
-            If this header is used, an application must be linked with the <libraryname>Boost.Regex</libraryname> 
-            library. 
-        </para>
-    </section>
-
-    <section>
-        <title>Examples</title>
-        <para>
-            Examples showing the basic usage of the library can be found in the libs/string_algo/example
-            directory. There is a separate file for the each part of the library. Please follow the boost
-            build guidelines to build examples using the bjam. To successfully build regex examples 
-            the <libraryname>Boost.Regex</libraryname> library is required. 
-        </para>
-    </section>
-
-    <section>
-        <title>Tests</title>
-        <para>
-            A full set of test cases for the library is located in the libs/string_algo/test directory. 
-            The test cases can be executed using the boost build system. For the tests of regular 
-            expression variants of algorithms, the <libraryname>Boost.Regex</libraryname> library is required. 
-        </para>
-    </section>
-
-    <section>
-        <title>Portability</title>
-        <para>
-            The library has been successfully compiled and tested with the following compilers:
-            
-            <itemizedlist>
-                <listitem>Microsoft Visual C++ 7.0</listitem>
-                <listitem>Microsoft Visual C++ 7.1</listitem>
-                <listitem>GCC 3.2</listitem>
-                <listitem>GCC 3.3.1</listitem>
-            </itemizedlist>
-        </para>
-        <para>
-            There are known limitation on platforms not supporting partial template specialization. 
-            Library depends on correctly implemented std::iterator_traits class. If a standard library provided 
-            with compiler is broken, the String Algorithm Library cannot function properly. Usually it implies 
-            that primitive pointer iterators are not working with the library functions. 
-        </para>
-    </section>
-</section>

string/doc/intro.xml

@@ -1,45 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<section id="string_algo.intro" last-revision="$Date$">
-    <title>Introduction</title>
-
-    <para>
-        The String Algorithm Library provides a generic implementation of
-        string-related algorithms which are missing in STL. It is an extension
-        to the algorithms library of STL and it includes trimming, case conversion, 
-        predicates and find/replace functions. All of them come in different variants 
-        so it is easier to choose the best fit for a particular need.
-    </para>
-    <para>
-        The implementation is not restricted to work with a particular container 
-        (like a <code>std::basic_string</code>), rather it is as generic as
-        possible. This generalization is not compromising the performance since
-        algorithms are using container specific features when it means a performance
-        gain.
-    </para>
-    <para>      
-        The library has layered structure to simplify the usage without sacrificing the
-        generalization. 
-
-        The easy-to-use interface, defined in the namespace <code>boost</code>, represents the first layer. 
-        Algorithms and classes defined here do not offer a lot of customization opportunities 
-        rather they are provided in more different variants, so a user can chose the 
-        one that suits her needs.
-
-        The second layer, defined in the namespace <code>boost::string_algo</code>, on the 
-        other hand, is generic. Basically it contains the same set of algorithms as the first layer,
-        but the interface is more flexible and allows more customization, but it is harder to use.
-        The first layer is implemented as set of wrappers around the second layer.
-    </para>
-    <para>
-        The documentation is divided into several sections. For a quick start read the 
-        <link linkend="string_algo.usage">Usage</link> section. 
-        <link linkend="string_algo.design">The Design Topics</link>,
-        <link linkend="string_algo.concept">Concepts</link> and <link linkend="string_algo.rationale">Rationale</link>
-        provide some explanation about the library design and structure an explain how it should be used.
-        See the <link linkend="string_algo.reference">Reference</link> for the complete list of provided utilities
-        and algorithms. Functions and classes in the reference are organized by the headers in which they are defined.
-        The reference contains links to the detailed description for every entity in the library.
-    </para>
-</section>

string/doc/rationale.xml

@@ -1,76 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<section id="string_algo.rationale" last-revision="$Date$">
-    <title>Rationale</title>
-
-    <using-namespace name="boost"/>
-    <using-namespace name="boost::string_algo"/>
-    
-    <section id="string_algo.structure">
-        <title>Library structure</title>
-
-        <para>
-            When designing a library it is always a problem to find a balance between generalization
-            and usability. A generic utility can have a wider range of usage with more options for extensibility,
-            but it can also bring unwanted complexity for everyday usage. 
-        </para>
-        <para>
-            Imagine a library for drawing geometric objects. It can contain one generic function <code>draw()</code>
-            with many parameters specifying what to draw, like size, number of edges, shape etc.
-            This would allow you to draw almost anything, but usually a user only needs to draw 
-            only a triangle or a square and she will have to specify this simple request in a 
-            very complicated way.For this purpose two functions, <code>draw_triangle()</code> and
-            <code>draw_square()</code>, would suit much better then a generic <code>draw()</code> function.
-        </para>
-        <para>
-            The String Algorithm Library solves this problem by dividing the interface into two layers.
-            The first layer (defined in the namespace boost) contains ready to use algorithms specialized
-            for common tasks. They are provided in multiple variants to better suit specific needs.
-            The second layer (defined in the namespace <code>boost::string_algo</code>), provides generic interfaces with
-            more options for extending and tunning. 
-        <para>
-        </para>
-            For instance, a <functionname>boost::trim()</functionname> algorithm trims spaces from 
-            an input string. When there is a need to trim something else, there is 
-            <functionname>boost::string_algo::trim()</functionname> which interface allows one to specify a 
-            predicate which selects the characters to be removed.
-        </para>
-    </section>
-    <section it="string_algo.locale">
-        <title>Locales</title>
-
-        <para>
-            Locales have a very close relation to string processing. They contain information about
-            the character sets and are used, for example, to change the case of characters and 
-            to classify the characters. 
-        </para>
-        <para>
-            C++ allows to work with multiple different instances of locales at once. If an algorithm
-            manipulates some data in a way that requires the usage of locales, there must be a way
-            to specify them. However, one instance of locales is sufficient for most of the applications,
-            and for a user it could be very tedious to specify which locales to use on every place 
-            where it is needed. 
-        </para> 
-        <para>
-            Fortunately, the C++ standard allows to specify the <emphasis>global</emphasis> locales (using static member
-            function <code>std:locale::global()</code>). When instantiating an
-            <code>std::locale</code> class without explicit information, the instance will 
-            be initialized with the <emphasis>global</emphasis> locale. It means, that if an algorithm needs a locale,
-            it should have an <code>std::locale</code> parameter with default value <code>std::locale()</code>.
-            If a user needs to specify locales explicitly, she can do so. Otherwise the <emphasis>global</emphasis>
-            locales are used.
-        </para>
-    </section>
-    <section id="string_algo.regex">
-        <title>Regular Expressions</title>
-
-        <para>
-            Regular expressions are an essential part of text processing. For this reason, the library 
-            provides also regex variants of some algorithms. The library does not try to replace
-            <libraryname>Boost.Regex</libraryname>, but it merely wraps its functionality in a new interface.
-            As a part of this library regex algorithms integrate smoothly with other components which 
-            brings additional value.
-        </para>
-    </section>
-</section>

string/doc/string_algo.xml

@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<library name="string_algo" dirname="string_algo" xmlns:xi="http://www.w3.org/2001/XInclude" 
-    id="string_algo" last-revision="$Date$">
-    <libraryinfo>
-        <author>
-            <firstname>Pavol</firstname>
-            <surname>Droba</surname>
-        </author>
-
-        <copyright>
-            <year>2002</year>
-            <year>2003</year>
-            <holder>Pavol Droba</holder>
-        </copyright>
-
-        <legalnotice>
-            <para>Use, modification and distribution is subject to the Boost
-                Software License, Version 1.0. (See accompanying file
-                <filename>LICENSE_1_0.txt</filename> or copy at <ulink
-                    url="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</ulink>)
-            </para>
-        </legalnotice>
-
-        <librarypurpose>
-            A set of generic string-related algorithms and utilities.
-        </librarypurpose> 
-        <librarycategory name="category:algoritms"/>
-    </libraryinfo>
-
-    <title>Boost String Algorithms Library</title>  
-    <xi:include href="intro.xml"/>
-    <xi:include href="usage.xml"/>
-    <xi:include href="design.xml"/>
-    <xi:include href="concept.xml"/>
-    <xi:include href="reference.boostbook"/>
-    <xi:include href="rationale.xml"/>
-    <xi:include href="environment.xml"/>
-    <xi:include href="credits.xml"/>
-</library>
-

string/doc/usage.xml

@@ -1,275 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<section id="string_algo.usage" last-revision="$Date$">
-    <title>Usage</title>
-
-    <using-namespace name="boost"/>
-    <using-namespace name="boost::string_algo"/>
-
-
-    <section>
-        <title>First Example</title>
-        
-        <para>
-            Using the algorithms is straightforward. Let us have a look at the first example:
-        </para>
-        <programlisting>
-    #include &lt;boost/string_algo.hpp&gt;
-    using namespace std;
-    using namespace boost;
-    namespace sa=boost::string_algo
-    
-    // ...
-
-    string str1(" hello world! ");
-    trim( to_upper(str1) );  // str1 == "HELLO WORLD!"
-
-    string str2=ireplace_first_copy(str1,"hello","goodbye"); // str2 == "goodbye WORLD!"
-        </programlisting>
-        <para>
-            This example converts str1 to upper case and trims spaces from the start and the end
-            of the string. str2 is then created as a copy of str1 with "hello" replaced with "goodbye".
-            This example demonstrates several important concepts used in the library:
-        </para>
-        <itemizedlist>
-            <listitem>
-                <para><emphasis role="bold">Container parameters:</emphasis>
-                    Unlike the STL algorithms, parameters are not specified only in form
-                    of iterators. The STL convention allows for great flexibility,
-                    but it has several limitation. It is not possible to <emphasis>stack</emphasis> algorithms together, 
-                    because a container is passed in two parameters, so it is not possible to use 
-                    a return value from another algorithm. It is considerably easier to write
-                    <code>to_lower(str1)</code>, then <code>to_lower(str1.begin(), str1.end())</code>.
-                </para>
-                <para>
-                    The magic of <link linkend="string_algo.container_traits">container_traits</link> 
-                    provides a uniform way of handling different containers. 
-                    If there is a need to pass a pair of iterators, 
-                    <link linkend="string_algo.iterator_range"><code>iterator_range</code></link>
-                    can be used to package iterators into a structure with the container interface.
-                </para>
-            </listitem>
-            <listitem>
-                <para><emphasis role="bold">Copy vs. Mutable:</emphasis>
-                    Many algorithms in the library are performing a transformation of the input. 
-                    The transformation can be done in-place, mutating the input sequence, or a copy 
-                    of the transformed input can be created, leaving the input intact. None of 
-                    these possibilities is superior to the other one and both have different 
-                    advantages and disadvantages. For this reason, both are provided with the library. 
-                </para>
-            </listitem>
-            <listitem>
-                <para><emphasis role="bold">Algorithm stacking:</emphasis>
-                    Copy versions return a transformed input as a result. Mutable variants return 
-                    a reference to the input. Thus both versions allow a simple chaining of
-                    transformations within one expression (i.e. one can write 
-                    <code>trim_copy(to_upper_copy(s))</code> as well as <code>trim(to_upper(s))</code>). 
-                </para>
-            </listitem>
-            <listitem>
-                <para><emphasis role="bold">Naming:</emphasis>
-                    Naming follows the conventions from the Standard C++ Library. If there is a 
-                    copy and mutable version of the same algorithm, the mutable version has no suffix 
-                    and the copy version has suffix <emphasis>_copy</emphasis>. 
-                    Some algorithms have prefix <emphasis>i</emphasis> 
-                    (e.g. <functionname>ifind_first()</functionname>).
-                    This prefix identifies that the algorithm works in a case-insensitive manner.
-                </para>
-            </listitem>
-        </itemizedlist>
-        <para>
-            To use the library, include the <headername>boost/string_algo.hpp</headername> header. 
-            If the regex related functions are needed, include the 
-            <headername>boost/string_algo_regex.hpp</headername> header.
-        </para>
-    </section>
-    <section>
-        <title>Case conversion</title>
-        
-        <para>
-            STL has a nice way of converting character case. Unfortunately, it works only
-            for a single character and we want to convert a string, 
-        </para>
-        <programlisting>
-    string str1("HeLlO WoRld!");
-    to_upper(str1); // str1=="HELLO WORLD!"
-        </programlisting>
-        <para>
-            <functionname>to_upper()</functionname> and <functionname>to_lower()</functionname> convert the case of 
-            characters in a container using a specified locale.
-        </para>
-    </section>
-    <section>
-        <title>Predicates and Classification</title>
-        <para>
-            A part of the library deals with string related predicates. Consider this example:
-        </para>
-        <programlisting>
-    bool is_executable( string&amp; filename )
-    {
-        return 
-            iends_with(filename, ".exe") ||
-            iends_with(filename, ".com");
-    }
-
-    // ...
-    string str1("command.com");
-    cout 
-        &lt;&lt; str1
-        &lt;&lt; is_executable("command.com")? "is": "is not" 
-        &lt;&lt; "an executable" 
-        &lt;&lt; endl; // prints "command.com is an executable"
-    
-    //..
-    char text1[]="hello world!";
-    cout 
-        &lt;&lt; text1 
-        &lt;&lt; all( text1, is_lower&lt;char&gt;() )? "is": "is not"
-        &lt;&lt; "written in the lower case" 
-        &lt;&lt; endl; // prints "hello world! is written in the lower case"
-        </programlisting>
-        <para>
-            The predicates are resolving if a substring is contained in the input string
-            under various conditions. The conditions are if a string starts with the substring, 
-            ends with the substring, 
-            simply contains the substring or if both strings are equal. See the reference for 
-            <headername>boost/string_algo/predicate.hpp</headername> for more details. 
-            In addition the algorithm <functionname>all()</functionname> checks
-            all elements of a container to satisfy a condition specified by a predicate. 
-            This predicate can be any unary predicate, but the library provides a bunch of 
-            useful string-related predicates ready for use.
-            These are located in the <headername>boost/string_algo/classification.hpp</headername> header.
-        </para>
-    </section>
-    <section>
-        <title>Trimming</title>
-        
-        <para>
-            When parsing the input of a user, strings usually have unwanted leading or trailing 
-            characters. To get rid of them, we need trim functions:
-        </para>
-        <programlisting>
-    string str1="     hello world!     ";
-    string str2=trim_left_copy(str1);   // str2 == "hello world!     "
-    string str3=trim_right_copy(str2);  // str3 == "     hello world!"
-    trim(str1);                         // str1 == "hello world!"
-
-    string phone="00423333444";
-    // remove leading 0 from the phone number
-    sa::trim_left(phone,is_any_of&lt;char&gt;("0")); // phone == "423333444"
-        </programlisting>
-        <para>
-            It is possible to trim the spaces on the right, on the left or on the both sides of a string.
-            And for those cases when there is a need to remove something else than blank space, the
-            <code>string_algo</code> namespace contains generic versions of the trim algorithms. Using these, 
-            a user can specify a functor which will select the <emphasis>space</emphasis> to be removed. It is possible to use 
-            classification predicates like <functionname>is_digit()</functionname> mentioned in the previous paragraph.
-            See the reference for the <headername>boost/string_algo/trim.hpp</headername>.
-        </para>
-    </section>
-    <section>
-        <title>Find algorithms</title>
-        
-        <para>
-            The library contains a set of find algorithms. Here is an example:
-        </para>
-        <programlisting>
-    char text[]="hello dolly!";
-    iterator_range&lt;char*&gt; result=find_last(text,"ll");
-
-    transform( result.begin(), result.end(), result.begin(), bind2nd(plus&lt;char&gt;(), 1) );
-    // text = "hello dommy!"            
-
-    to_upper(result); // text == "hello doMMy!"
-        </programlisting>
-        <para>
-            We have used <functionname>find_last()</functionname> to search the <code>text</code> for "ll".
-            The result is given in the <link linkend="string_algo.iterator_range"><code>iterator_range</code></link>. 
-            This range delimits the
-            part of the input which satisfies the find criteria. In our example it is the last occurrence of "ll".
-            
-            As we can see, input of the <functionname>find_last()</functionname> algorithm can be also 
-            char[] because this type is supported by 
-            <link linkend="string_algo.container_traits">container_traits</link>.
-
-            Following lines transform the result. Notice, that 
-            <link linkend="string_algo.iterator_range"><code>iterator_range</code></link> have familiar 
-            <code>begin()</code> and <code>end()</code> methods, so it can be used like any other STL container.
-        </para>
-    </section>
-    <section>
-        <title>Replace Algorithms</title>
-        <para>
-            Find algorithms can be used for searching for a specific part of the sequence. Replace goes one step
-            further. After a matching part is found, it is substituted with something else. The substitution is computed
-            from an original, using some transformation. 
-        </para>
-        <programlisting>
-    string str1="Hello  Dolly,   Hello World!"
-    replace_first(str1, "Dolly", "Jane");      // str1 == "Hello  Jane,   Hello World!"
-    replace_last(str1, "Hello", "Goodbye");    // str1 == "Hello  Jane,   Goodbye World!"
-    erase_all(str1, " ");                      // str1 == "HelloJane,GoodbyeWorld!"
-    erase_head(str1, 6);                       // str1 == "Jane,GoodbyeWorld!"
-        </programlisting>
-        <para>
-            For the complete list of replace and erase functions see the 
-            <link linkend="string_algo.reference">reference</link>.
-            There is a lot of predefined function for common usage, however, the library allows you to 
-            define a custom <code>replace()</code> that suits a specific need. There is a generic <functionname>replace()</functionname> 
-            function which takes two parameters.
-            The first one is a <link linkend="string_algo.finder_concept">Finder</link> object, the second one is 
-            a <link linkend="string_algo.formatter_concept">Formatter</link> object. 
-            The Finder object is a functor which performs the searching for the replacement part. The Formatter object
-            takes the result of the Finder (usually a reference to the found substring) and creates a 
-            substitute for it. Replace algorithm puts these two together and makes the desired substitution. 
-        </para>
-    </section>
-    <section>
-        <title>Split</title>
-
-        <para>
-            Split algorithms allow one to divide a sequence into parts. Each part represents a 
-            <emphasis>token</emphasis> and  tokens are separated by <emphasis>separators</emphasis>. 
-            One can either search for tokens or search for separators:
-        </para>
-
-        <programlisting>
-    string str1("hello abc-*-ABC-*-aBc goodbye");
-
-    typedef vector&lt; iterator_range&lt;string::iterator&gt; &gt; find_vector_type;
-    
-    find_vector_type FindVec; // #1: Search for separators
-    ifind_all( FindVec, str1, "abc" ); // FindVec == { [abc],[ABC],[aBc] }
-
-    typdef vector&lt; string &gt; split_vector_type;
-    
-    split_vector_type SplitVec; // #2: Search for tokens
-    split( SplitVec, str1, is_any_of&lt;char&gt;("-*") ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
-        </programlisting>
-        <para>
-            <code>[hello]</code> designates an <code>iterator_range</code> delimiting this substring.                       
-        </para>
-        <para>
-            The result of a split algorithm is a <emphasis>container of containers</emphasis>. There is only one restriction:
-            The inner container type must be able to hold extracted parts of the input sequence. This example 
-            shows the special case where the inner container is an 
-            <link linkend="string_algo.iterator_range"><code>iterator_range</code></link> 
-            instead of e.g. <code>std::string</code>. This way, a user gets a reference 
-            (in the form of iterators) delimiting the parts of the input sequence. Otherwise, a copy of 
-            each extracted part is created and added to the outer container.
-        </para>
-        <para>
-            So to recap, there are two basic algorithms: <functionname>find_all()</functionname> 
-            returns extracts the parts
-            matching the specification whereas <functionname>split()</functionname> uses the matching 
-            parts as delimiters, and extracts the parts in between them. 
-        </para>
-        <para>
-            Generalizations of these two algorithms are called <functionname>iter_find()</functionname> and 
-            <functionname>iter_split()</functionname>. They take a 
-            <link linkend="string_algo.finder_concept">Finder</link> object, as an argument to search for 
-            the substring. 
-        </para>     
-    </section>
-</section>

string/example/Jamfile

@@ -1,75 +0,0 @@
-#  Boost string_algo library examples Jamfile  ---------------------------------
-#
-#  Copyright Pavol Droba 2002-2003. Use, modification and
-#  distribution is subject to 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 for updates, documentation, and revision history.
-
-subproject libs/algorithm/string/example ;
-
-exe conv_example
-    :
-    conv_example.cpp
-    :
-    <include>$(BOOST_ROOT)     
-    :
-    ;
-
-exe predicate_example
-    :
-    predicate_example.cpp
-    :
-    <include>$(BOOST_ROOT)     
-    :
-    ;
-
-exe find_example
-    :
-    find_example.cpp 
-    :
-    <include>$(BOOST_ROOT)     
-    :
-    ;
-
-exe replace_example
-    :
-    replace_example.cpp
-    :
-    <include>$(BOOST_ROOT)     
-    :
-    ;
-
-exe rle_example
-    :
-    rle_example.cpp
-    :
-    <include>$(BOOST_ROOT)     
-    :
-    ;
-
-exe trim_example
-    :
-    trim_example.cpp
-    :
-    <include>$(BOOST_ROOT)
-    :
-    ;
-
-exe regex_example
-    :
-    regex_example.cpp
-    <lib>../../../regex/build/boost_regex
-    :
-    <include>$(BOOST_ROOT)     
-    :
-    ;
-
-exe split_example
-    :
-    split_example.cpp
-    :
-    <include>$(BOOST_ROOT)
-    :
-    ;

string/example/conv_example.cpp

@@ -1,41 +0,0 @@
-//  Boost string_algo library example file  ---------------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#include <string>
-#include <vector>
-#include <iostream>
-#include <iterator>
-#include <boost/algorithm/string/case_conv.hpp>
-
-using namespace std;
-using namespace boost;
-
-int main()
-{  
-    cout << "* Case Conversion Example *" << endl << endl;
-
-    string str1("AbCdEfG");
-    vector<char> vec1( str1.begin(), str1.end() );
-    
-    // Convert vector of chars to lower case
-    cout << "lower-cased copy of vec1: ";
-    to_lower_copy( ostream_iterator<char>(cout), vec1 );
-    cout << endl;
-
-    // Conver string str1 to upper case ( copy the input )
-    cout << "upper-cased copy of str1: " << to_upper_copy( str1 ) << endl;
-
-    // Inplace conversion
-    to_lower( str1 );
-    cout << "lower-cased str1: " << str1 << endl;
-
-    cout << endl;
-
-    return 0;
-}

string/example/find_example.cpp

@@ -1,58 +0,0 @@
-//  Boost string_algo library example file  ---------------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#include <string>
-#include <iostream>
-#include <algorithm>
-#include <functional>
-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/algorithm/string/find.hpp>
-
-using namespace std;
-using namespace boost;
-
-int main()
-{  
-    cout << "* Find Example *" << endl << endl;
-
-    string str1("abc___cde___efg");
-    string str2("abc");
-
-    // find "cde" substring
-    iterator_range<string::iterator> range=find_first( str1, string("cde") );
-
-    // convert a substring to upper case 
-    // note that iterator range can be directly passed to the algorithm
-    to_upper( range );
-
-    cout << "str1 with upper-cased part matching cde: " << str1 << endl;
-
-    // get a head of the string
-    iterator_range<string::iterator> head=find_head( str1, 3 );
-    cout << "head(3) of the str1: " << string( head.begin(), head.end() ) << endl;
-
-    // get the tail
-    head=find_tail( str2, 5 );
-    cout << "tail(5) of the str2: " << string( head.begin(), head.end() ) << endl;
-
-    // char processing
-    char text[]="hello dolly!";
-    iterator_range<char*> crange=find_last(text,"ll");
-
-    // transform the range ( add 1 )
-    transform( crange.begin(), crange.end(), crange.begin(), bind2nd( plus<char>(), 1 ) );
-    // uppercase the range
-    to_upper( crange );
-
-    cout << text << endl;
-
-    cout << endl;
-
-    return 0;
-}

string/example/predicate_example.cpp

@@ -1,61 +0,0 @@
-//  Boost string_algo library example file  ---------------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#include <string>
-#include <iostream>
-#include <functional>
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/bind.hpp>
-
-
-using namespace std;
-using namespace boost;
-
-int main()
-{
-    cout << "* Predicate Example *" << endl << endl;
-
-    string str1("123xxx321");
-    string str2("abc");
-
-    // Check if str1 starts with '123'
-    cout << "str1 starts with \"123\": " << 
-        (starts_with( str1, string("123") )?"true":"false") << endl; 
-    
-    // Check if str1 ends with '123'
-    cout << "str1 ends with \"123\": " << 
-        (ends_with( str1, string("123") )?"true":"false") << endl; 
-
-    // Check if str1 containes 'xxx'
-    cout << "str1 contains \"xxx\": " << 
-        (contains( str1, string("xxx") )?"true":"false") << endl; 
-
-
-    // Check if str2 equals to 'abc'
-    cout << "str2 equals \"abc\": " << 
-        (equals( str2, string("abc") )?"true":"false") << endl; 
-
-
-    // Classification functors and all predicate
-    if ( all(";.,", is_punct() ) )
-    {
-        cout << "\";.,\" are all punctuation characters" << endl;  
-    }
-
-    // Classification predicated can be combined 
-    if ( all("abcxxx", is_any_of("xabc") && !is_space() ) )
-    {
-        cout << "true" << endl;
-    }
-
-    cout << endl;
-
-    return 0;
-}   

string/example/regex_example.cpp

@@ -1,42 +0,0 @@
-//  Boost string_algo library example file  ---------------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#include <string>
-#include <iostream>
-#include <iterator>
-#include <boost/regex.hpp>
-#include <boost/algorithm/string/regex.hpp>
-
-using namespace std;
-using namespace boost;
-
-int main()
-{  
-    cout << "* Regex Example *" << endl << endl;
-
-    string str1("abc__(456)__123__(123)__cde");
-
-    // Replace all substrings matching (digit+) 
-    cout << 
-        "replace all (digit+) in str1 with #digit+# :" <<
-        replace_all_regex_copy( str1, regex("\\(([0-9]+)\\)"), string("#$1#") ) << endl;
-    
-    // Erase all substrings matching (digit+) 
-    cout << 
-        "remove all sequences of letters from str1 :" <<
-        erase_all_regex_copy( str1, regex("[[:alpha:]]+") ) << endl;
-
-    // in-place regex transformation
-    replace_all_regex( str1, regex("_(\\([^\\)]*\\))_"), string("-$1-") );
-    cout << "transformad str1: " << str1 << endl;
-
-    cout << endl;
-
-    return 0;
-}

string/example/replace_example.cpp

@@ -1,88 +0,0 @@
-//  Boost string_algo library example file  ---------------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#include <string>
-#include <iostream>
-#include <iterator>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/algorithm/string/erase.hpp>
-#include <boost/algorithm/string/case_conv.hpp>
-
-//Following two includes contain second-layer function.
-//They are already included by first-layer header
-
-//#include <boost/algorithm/string/replace2.hpp>
-//#include <boost/algorithm/string/find2.hpp>
-
-using namespace std;
-using namespace boost;
-
-// uppercase formatter
-/*
-    Convert an input to upper case. 
-    Note, that this formatter can be used only on std::string inputs.
-*/
-inline string upcase_formatter( 
-    const iterator_range<string::const_iterator>& Replace )
-{
-    string Temp(Replace.begin(), Replace.end());
-    to_upper(Temp);
-    return Temp;
-}
-
-int main()
-{  
-    cout << "* Replace Example *" << endl << endl;
-
-    string str1("abc___cde___efg");
-
-    // Erase 6-9th characters from the string
-    cout << "str1 without 6th to 9th character:" <<
-        erase_range_copy( str1, make_iterator_range(str1.begin()+6, str1.begin()+9) ) << endl;
-
-    // Replace 6-9th character with '+++'
-    cout << "str1 with 6th to 9th character replaced with '+++': " << 
-        replace_range_copy( 
-            str1, make_iterator_range(str1.begin()+6, str1.begin()+9), "+++" ) << endl;
-
-    cout << "str1 with 'cde' replaced with 'XYZ': ";
-    
-    // Replace first 'cde' with 'XYZ'. Modify the input
-    replace_first_copy( ostream_iterator<char>(cout), str1, "cde", "XYZ" );
-    cout << endl;
-    
-    // Replace all '___'
-    cout << "str1 with all '___' replaced with '---': " << 
-        replace_all_copy( str1, "___", "---" ) << endl;
-
-    // Erase all '___'
-    cout << "str1 without all '___': " << 
-        erase_all_copy( str1, "___" ) << endl;
-
-    // replace third and 5th occurrence of _ in str1
-    // note that nth argument is 0-based
-    replace_nth( str1, "_", 4, "+" );
-    replace_nth( str1, "_", 2, "+" );
-
-    cout << "str1 with third and 5th occurrence of _ replace: " << str1 << endl;
-
-    // Custom formatter examples
-    string str2("abC-xxxx-AbC-xxxx-abc");
-
-    // Find string 'abc' ignoring the case and convert it to upper case
-    cout << "Upcase all 'abc'(s) in the str2: " <<
-        find_format_all_copy( 
-            str2,
-            first_finder("abc", is_iequal()), 
-            upcase_formatter );
-    
-    cout << endl;
-
-    return 0;
-}

string/example/rle_example.cpp

@@ -1,241 +0,0 @@
-//  Boost string_algo library example file  ---------------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-/*
-    RLE compression using replace framework. Goal is to compress a sequence of
-    repeating characters into 3 bytes ( repeat mark, character and repetition count ).
-    For simplification, it works only on numeric-value sequences.
-*/
-
-#include <string>
-#include <iostream>
-#include <limits>
-#include <boost/detail/iterator.hpp>
-#include <boost/algorithm/string/find_format.hpp>
-#include <boost/algorithm/string/finder.hpp>
-
-using namespace std;
-using namespace boost;
-
-// replace mark specification, specialize for a specific element type
-template< typename T > T repeat_mark() { return std::numeric_limits<T>::max(); };
-
-// Compression  -----------------------------------------------------------------------
-
-
-// compress finder -rle
-/*
-    Find a sequence which can be compressed. It has to be at least 3-character long
-    sequence of repetitive characters 
-*/
-struct find_compressF 
-{
-    // Construction
-    find_compressF() {}
-
-    // Operation
-    template<typename ForwardIteratorT>
-    iterator_range<ForwardIteratorT> operator()( 
-        ForwardIteratorT Begin, 
-        ForwardIteratorT End ) const
-    {
-        typedef ForwardIteratorT input_iterator_type;
-        typedef typename boost::detail::iterator_traits<input_iterator_type>::value_type value_type;
-        typedef iterator_range<input_iterator_type> result_type;
-
-        // begin of the matching segment
-        input_iterator_type MStart=End;
-        // Repetition counter
-        value_type Cnt=0;
-
-        // Search for a sequence of repetitive characters
-        for(input_iterator_type It=Begin; It!=End;)
-        {
-            input_iterator_type It2=It++;
-
-            if ( It==End || Cnt>=std::numeric_limits<value_type>::max() )
-            {
-                return result_type( MStart, It );
-            }
-
-            if ( *It==*It2 )
-            {
-                if ( MStart==End )
-                {
-                    // Mark the start
-                    MStart=It2;
-                }
-
-                // Increate repetition counter
-                Cnt++;
-            }
-            else
-            {
-                if ( MStart!=End )
-                {
-                    if ( Cnt>2 )
-                        return result_type( MStart, It );
-                    else
-                    {
-                        MStart=End;
-                        Cnt=0;
-                    }
-                }
-            }
-        }
-
-        return result_type( End, End );
-    }
-};
-
-// rle compress format
-/*
-    Transform a sequence into repeat mark, character and count 
-*/
-template<typename SeqT>
-struct format_compressF
-{
-private:
-    typedef SeqT result_type;
-    typedef typename SeqT::value_type value_type;
-
-public:
-    // Construction
-    format_compressF() {};
-
-    // Operation
-    template< typename ReplaceT >
-    result_type operator()( const ReplaceT& Replace ) const
-    {
-        SeqT r;
-        r.push_back( repeat_mark<value_type>() );
-        r.push_back( *(Replace.begin()) );
-        r.push_back( value_type( Replace.size() ) );
-        
-        return r;
-    }
-};
-
-// Decompression  -----------------------------------------------------------------------
-
-
-// find decompress-rle functor
-/*
-    find a repetition block
-*/
-struct find_decompressF
-{
-    // Construction
-    find_decompressF() {}
-
-    // Operation
-    template<typename ForwardIteratorT>
-    iterator_range<ForwardIteratorT> operator()( 
-        ForwardIteratorT Begin, 
-        ForwardIteratorT End ) const
-    {
-        typedef ForwardIteratorT input_iterator_type;
-        typedef typename boost::detail::iterator_traits<input_iterator_type>::value_type value_type;
-        typedef iterator_range<input_iterator_type> result_type;
-
-        for(input_iterator_type It=Begin; It!=End; It++)
-        {
-            if( *It==repeat_mark<value_type>() )
-            {
-                // Repeat mark found, extract body
-                input_iterator_type It2=It++; 
-                
-                if ( It==End ) break;
-                    It++; 
-                if ( It==End ) break;
-                    It++;
-                
-                return result_type( It2, It );
-            }
-        }
-
-        return result_type( End, End );
-    }
-};
-
-// rle decompress format
-/*
-    transform a repetition block into a sequence of characters
-*/
-template< typename SeqT >
-struct format_decompressF
-{
-private:
-    typedef SeqT result_type;
-    typedef typename SeqT::value_type value_type;
-
-public:
-    // Construction
-    format_decompressF() {};
-
-    // Operation
-    template< typename ReplaceT >
-    result_type operator()( const ReplaceT& Replace ) const
-    {
-        // extract info
-        typename ReplaceT::const_iterator It=Replace.begin();
-
-        value_type Value=*(++It);
-        value_type Repeat=*(++It);
-        
-        SeqT r;
-        for( value_type Index=0; Index<Repeat; Index++ ) r.push_back( Value );
-
-        return r;
-    }
-};
-
-
-int main()
-{
-    cout << "* RLE Compression Example *" << endl << endl;
-
-    string original("123_AA_*ZZZZZZZZZZZZZZ*34");
-
-    // copy compression
-    string compress=find_format_all_copy( 
-        original, 
-        find_compressF(), 
-        format_compressF<string>() );
-
-    cout << "Compressed string: " << compress << endl;
-
-    // Copy decompression
-    string decompress=find_format_all_copy( 
-        compress, 
-        find_decompressF(), 
-        format_decompressF<string>() );
-
-    cout << "Decompressed string: " << decompress << endl;
-
-    // in-place compression
-    find_format_all( 
-        original, 
-        find_compressF(), 
-        format_compressF<string>() );
-    
-    cout << "Compressed string: " << original << endl;
-
-    // in-place decompression
-    find_format_all( 
-        original, 
-        find_decompressF(), 
-        format_decompressF<string>() );
-
-    cout << "Decompressed string: " << original << endl;
-
-    cout << endl;
-
-    return 0;
-}

string/example/split_example.cpp

@@ -1,63 +0,0 @@
-//  Boost string_algo library example file  ---------------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#include <string>
-#include <vector>
-#include <iostream>
-#include <iterator>
-#include <functional>
-#include <boost/algorithm/string/iterator_range.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/find_iterator.hpp>
-
-using namespace std;
-using namespace boost;
-
-int main()
-{  
-    cout << "* Split Example *" << endl << endl;
-
-    string str1("abc-*-ABC-*-aBc");
-
-    cout << "Before: " << str1 << endl;
-
-    // Find all 'abc' substrings (ignoring the case)
-    // Create a find_iterator
-    typedef find_iterator<string::iterator> string_find_iterator;
-    for(string_find_iterator It=
-            make_find_iterator(str1, first_finder("abc", is_iequal()));
-        It!=string_find_iterator();
-        ++It)
-    {
-        cout << copy_iterator_range<std::string>(*It) << endl;
-        // shift all chars in the match by one
-        transform( 
-            It->begin(), It->end(), 
-            It->begin(), 
-            bind2nd( plus<char>(), 1 ) );
-    }
-
-    // Print the string now
-    cout << "After: " << str1 << endl;
-    
-    // Split the string into tokens ( use '-' and '*' as delimiters )
-    // We need copies of the input only, and adjacent tokens are compressed
-    vector<std::string> ResultCopy;
-    split(ResultCopy, str1, is_any_of("-*"), token_compress_on);
-
-    for(unsigned int nIndex=0; nIndex<ResultCopy.size(); nIndex++)
-    {
-        cout << nIndex << ":" << ResultCopy[nIndex] << endl;
-    };
-
-    cout << endl;
-
-    return 0;
-}

string/example/trim_example.cpp

@@ -1,47 +0,0 @@
-//  Boost string_algo library example file  ---------------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-#include <string>
-#include <iostream>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/algorithm/string/classification.hpp>
-
-using namespace std;
-using namespace boost;
-
-int main()
-{
-    cout << "* Trim Example *" << endl << endl;
-
-    string str1("     1x x x x1     ");
-    string str2("<>trim<>");
-    string str3("123abs343");
-
-    // Simple left trim
-    cout << "trim_left copy of str1: " << "\"" << trim_left_copy( str1 ) << "\"" << endl;
-
-    // Inplace right trim
-    trim_right( str1 );
-    cout << "trim_right on str1: " << "\"" << str1 << "\"" << endl;
-
-    // Parametric trim. 'Space' is defined using is_any_of predicate
-    cout 
-        << "trimmed copy of str4 ( space='<>' ): " 
-        << "\""<< trim_copy_if( str2, is_any_of("<>") ) << "\"" << endl;
-    
-
-    // Parametric trim. 'Space' is defined using is_digit predicate
-    cout 
-        << "trimmed copy of str5 ( space=digit ): " 
-        << "\"" << trim_copy_if( str3, is_digit() ) << "\"" << endl;
-
-    cout << endl;
-
-    return 0;
-}

string/test/Jamfile

@@ -1,71 +0,0 @@
-#  Boost string_algo library test suite Jamfile  ----------------------------
-#
-#  Copyright Pavol Droba 2002-2003. Use, modification and
-#  distribution is subject to 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 for updates, documentation, and revision history.
-
-subproject libs/algorithm/string/test ;
-
-# bring in rules for testing
-import testing ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-    test-suite string_algo
-        : [ run
-                container_test.cpp
-              : :
-                :
-                : container
-            ]
-          [ run 
-                trim_test.cpp
-              : :
-                :
-                : trim
-            ]
-          [ run 
-                conv_test.cpp
-              : :
-                :
-                : conv
-            ]
-          [ run 
-                predicate_test.cpp
-              : :
-                :
-                : predicate
-            ]
-          [ run 
-                find_test.cpp
-              : :
-                :
-                : find
-            ]
-          [ run
-                split_test.cpp
-              : :
-                :
-                : split
-            ]
-          [ run 
-                replace_test.cpp
-              : :
-                :
-                : replace
-            ]
-          [ run 
-                regex_test.cpp
-                <lib>../../../regex/build/boost_regex
-              : :
-                :   
-                : regex
-            ]
-        ;
-}
-

string/test/container_test.cpp

@@ -1,127 +0,0 @@
-//  Boost string_algo library substr_test.cpp file  ------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <boost/algorithm/string/collection_traits.hpp>
-#include <boost/type_traits.hpp>
-
-// equals predicate is used for result comparison
-#include <boost/algorithm/string/predicate.hpp>
-
-// test tools
-#include <boost/test/test_tools.hpp>
-
-
-using namespace std;
-using namespace boost;
-
-namespace algo = ::boost::algorithm;
-
-template< typename T >
-void argument_cv_test( const T& C, const string& strResult )
-{
-    BOOST_CHECK( equals( make_iterator_range(algo::begin(C),algo::end(C)), strResult ) );
-    BOOST_CHECK( algo::size(C)==strResult.size() );
-    BOOST_CHECK( algo::empty(C)==strResult.empty() );
-}
-
-template< typename T >
-void argument_test( T& C, const string& strResult )
-{
-    BOOST_CHECK( equals( make_iterator_range(algo::begin(C),algo::end(C)), strResult ) );
-    BOOST_CHECK( algo::size(C)==strResult.size() );
-    BOOST_CHECK( algo::empty(C)==strResult.empty() );
-}
-
-void container_test()
-{
-    BOOST_CHECKPOINT( "type test" );
-        
-    // types test
-    BOOST_REQUIRE( (is_same< 
-        algo::result_iterator_of<string>::type, 
-        string::iterator>::value) );
-    BOOST_REQUIRE( (is_same< 
-        algo::result_iterator_of<const string>::type, 
-        string::const_iterator>::value) );
-    BOOST_REQUIRE( (is_same< 
-        algo::result_iterator_of<char[4]>::type, char*>::value) );
-    BOOST_REQUIRE( (is_same< 
-        algo::result_iterator_of<const char[4]>::type, 
-        const char*>::value) );
-    BOOST_REQUIRE( (is_same< 
-        algo::result_iterator_of<char*>::type, char*>::value) );
-    BOOST_REQUIRE( (is_same< 
-        algo::result_iterator_of<const char*>::type, 
-        const char*>::value) );
-    BOOST_REQUIRE( (is_same< 
-        algo::result_iterator_of<
-            pair<string::iterator, string::iterator> >::type, string::iterator>::value) );
-    BOOST_REQUIRE( (is_same< 
-         algo::result_iterator_of<
-            const pair<string::iterator, string::iterator> >::type, 
-            string::iterator>::value) );
-
-    BOOST_CHECKPOINT( "non-empty sequence test" );
-    
-    string str1("abc");
-    vector<char> vec1( str1.begin(), str1.end() );
-    pair<string::iterator, string::iterator> pair1=
-        make_pair( str1.begin(), str1.end() );
-    char ach1[]="abc";
-    char *pch1="abc";
-
-    // begin/end tests
-    argument_cv_test( str1, "abc" );
-    argument_test( str1, "abc" );
-    argument_cv_test( vec1, "abc" );
-    argument_test( vec1, "abc" );
-    argument_cv_test( pair1, "abc" );
-    argument_test( pair1, "abc" );
-    argument_cv_test( ach1, "abc" );
-    argument_test( ach1, "abc" );
-    argument_cv_test( pch1, "abc" );
-    argument_test( pch1, "abc" );
-
-    BOOST_CHECKPOINT( "empty sequence test" );
-
-    string str2;
-    vector<char> vec2( str2.begin(), str2.end() );
-    pair<string::iterator, string::iterator> pair2=
-        make_pair( str2.begin(), str2.end() );
-    char ach2[]="";
-    char *pch2=0;
-
-    // begin/end tests
-    argument_cv_test( str2, "" );
-    argument_test( str2, "" );
-    argument_cv_test( vec2, "" );
-    argument_test( vec2, "" );
-    argument_cv_test( pair2, "" );
-    argument_test( pair2, "" );
-    argument_cv_test( ach2, "" );
-    argument_test( ach2, "" );
-    argument_cv_test( pch2, "" );
-    argument_test( pch2, "" );
-};
-
-
-// test main 
-int test_main( int, char*[] )
-{
-    container_test();
-
-    return 0;
-}

string/test/conv_test.cpp

@@ -1,94 +0,0 @@
-//  Boost string_algo library conv_test.cpp file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <iostream>
-#include <algorithm>
-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/test/test_tools.hpp>
-
-using namespace std;
-using namespace boost;
-
-void conv_test()
-{
-    string str1("AbCdEfG 123 xxxYYYzZzZ");
-    string str2("AbCdEfG 123 xxxYYYzZzZ");
-    string str3("");
-    const char pch[]="AbCdEfG 123 xxxYYYzZzZ";    
-    unsigned int pchlen=sizeof(pch);
-
-    char* pch1=new char[pchlen];
-    std::copy(pch, pch+pchlen, pch1);
-    char* pch2=new char[pchlen];
-    std::copy(pch, pch+pchlen, pch2);
-
-    // *** iterator tests *** //
-
-    string strout;
-    to_lower_copy( back_inserter(strout), str1 );
-    BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" );
-    strout.clear();
-    to_upper_copy( back_inserter(strout), str1 );
-    BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" );
-
-    strout.clear();
-    to_lower_copy( back_inserter(strout), "AbCdEfG 123 xxxYYYzZzZ" );
-    BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" );
-    strout.clear();
-    to_upper_copy( back_inserter(strout), "AbCdEfG 123 xxxYYYzZzZ" );
-    BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" );
-
-    strout.clear();
-    to_lower_copy( back_inserter(strout), pch1 );
-    BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" );
-    strout.clear();
-    to_upper_copy( back_inserter(strout), pch1 );
-    BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" );
-
-    // *** value passing tests *** //
-
-    BOOST_CHECK( to_lower_copy( str1 )=="abcdefg 123 xxxyyyzzzz" );
-    BOOST_CHECK( to_upper_copy( str1 )=="ABCDEFG 123 XXXYYYZZZZ" );
-
-    BOOST_CHECK( to_lower_copy( str3 )=="" );
-    BOOST_CHECK( to_upper_copy( str3 )=="" );
-
-    // *** inplace tests *** //
-
-    to_lower( str1 );
-    BOOST_CHECK( str1=="abcdefg 123 xxxyyyzzzz" );
-    to_upper( str2 );
-    BOOST_CHECK( str2=="ABCDEFG 123 XXXYYYZZZZ" );
-
-    // c-string modification
-    to_lower( pch1 );
-    BOOST_CHECK( string(pch1)=="abcdefg 123 xxxyyyzzzz" );
-    to_upper( pch2 );
-    BOOST_CHECK( string(pch2)=="ABCDEFG 123 XXXYYYZZZZ" );
-
-    to_lower( str3 );
-    BOOST_CHECK( str3=="" );
-    to_upper( str3 );
-    BOOST_CHECK( str3=="" );
-
-    free(pch1);
-    free(pch2);
-}
-
-// test main 
-int test_main( int, char*[] )
-{
-    conv_test();
-    
-    return 0;
-}

string/test/find_test.cpp

@@ -1,230 +0,0 @@
-//  Boost string_algo library substr_test.cpp file  ------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <vector>
-#include <iostream>
-#include <iterator>
-#include <sstream>
-#include <boost/algorithm/string/find.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/test/test_tools.hpp>
-
-using namespace std;
-using namespace boost;
-
-void find_test()
-{
-    string str1("123abcxXxabcXxXabc321");
-    string str2("abc");
-    string str3("");
-    char* pch1="123abcxxxabcXXXabc321";
-    vector<int> vec1( str1.begin(), str1.end() );
-
-    // find results ------------------------------------------------------------//
-    iterator_range<string::iterator> nc_result;
-    iterator_range<string::const_iterator> cv_result;
-    
-    iterator_range<vector<int>::iterator> nc_vresult;
-    iterator_range<vector<int>::const_iterator> cv_vresult;
-
-    iterator_range<const char*> ch_result;
-
-    // basic tests ------------------------------------------------------------//
-
-
-    // find_first
-    BOOST_CHECKPOINT( "find_first" );
-
-    nc_result=find_first( str1, string("abc") );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
-
-    cv_result=find_first( const_cast<const string&>(str1), str2 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
-
-    cv_result=ifind_first( const_cast<const string&>(str1), "xXX" );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 6) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 9) );
-
-    ch_result=find_first( pch1, "abc" );
-    BOOST_CHECK(( (ch_result.begin() - pch1 ) == 3) && ( (ch_result.end() - pch1 ) == 6 ) );
-
-    // find_last
-    BOOST_CHECKPOINT( "find_last" );
-    
-    nc_result=find_last( str1, string("abc") );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 15) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 18) );
-
-    cv_result=find_last( const_cast<const string&>(str1), str2 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 15) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 18) );
-
-    cv_result=ifind_last( const_cast<const string&>(str1), "XXx" );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 12) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 15) );
-
-    ch_result=find_last( pch1, "abc" );
-    BOOST_CHECK(( (ch_result.begin() - pch1 ) == 15) && ( (ch_result.end() - pch1 ) == 18 ) );
-
-    // find_nth
-    BOOST_CHECKPOINT( "find_nth" );
-
-    nc_result=find_nth( str1, string("abc"), 1 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 9) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 12) );
-
-    cv_result=find_nth( const_cast<const string&>(str1), str2, 1 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 9) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 12) );
-        
-    cv_result=ifind_nth( const_cast<const string&>(str1), "xxx", 1 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 12) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 15) );
-
-    ch_result=find_nth( pch1, "abc", 1 );
-    BOOST_CHECK(( (ch_result.begin() - pch1 ) == 9) && ( (ch_result.end() - pch1 ) == 12 ) );
-
-    // find_head
-    BOOST_CHECKPOINT( "find_head" );
-
-    nc_result=find_head( str1, 6 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 0) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
-
-    cv_result=find_head( const_cast<const string&>(str1), 6 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 0) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
-
-    ch_result=find_head( pch1, 6 );
-    BOOST_CHECK( ( (ch_result.begin() - pch1 ) == 0 ) && ( (ch_result.end() - pch1 ) == 6 ) );
-
-    // find_tail
-    BOOST_CHECKPOINT( "find_tail" );
-
-    nc_result=find_tail( str1, 6 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 15) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 21) );
-
-    cv_result=find_tail( const_cast<const string&>(str1), 6 );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 15) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 21) );
-
-    ch_result=find_tail( pch1, 6 );
-    BOOST_CHECK( ( (ch_result.begin() - pch1 ) == 15 ) && ( (ch_result.end() - pch1 ) == 21 ) );
-
-    // find_token
-    BOOST_CHECKPOINT( "find_token" );
-
-    nc_result=find_token( str1, is_any_of("abc"), token_compress_on );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
-
-    cv_result=find_token( const_cast<const string&>(str1), is_any_of("abc"), token_compress_on );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
-
-    nc_result=find_token( str1, is_any_of("abc"), token_compress_off );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 4) );
-
-    cv_result=find_token( const_cast<const string&>(str1), is_any_of("abc"), token_compress_off );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 4) );
-
-    ch_result=find_token( pch1, is_any_of("abc"), token_compress_off );
-    BOOST_CHECK( ( (ch_result.begin() - pch1 ) == 3 ) && ( (ch_result.end() - pch1 ) == 4 ) );
-
-    // generic find
-    BOOST_CHECKPOINT( "generic find" );
-
-    nc_result=find(str1, first_finder(string("abc")));
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
-
-    cv_result=find(const_cast<const string&>(str1), first_finder(str2) );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
-
-    // multi-type comparison test 
-    BOOST_CHECKPOINT( "multi-type" );
-
-    nc_vresult=find_first( vec1, string("abc") );
-    BOOST_CHECK( 
-        (distance<vector<int>::const_iterator>( vec1.begin(),nc_vresult.begin()) == 3) &&
-        (distance<vector<int>::const_iterator>( vec1.begin(),nc_vresult.end()) == 6) );
-
-    cv_vresult=find_first( const_cast<const vector<int>&>(vec1), str2 );
-    BOOST_CHECK( 
-        (distance<vector<int>::const_iterator>( vec1.begin(),cv_vresult.begin()) == 3) &&
-        (distance<vector<int>::const_iterator>( vec1.begin(),cv_vresult.end()) == 6) );
-
-    // overflow test
-    BOOST_CHECKPOINT( "overflow" );
-    
-    nc_result=find_first( str2, string("abcd") );
-    BOOST_CHECK( nc_result.begin()==nc_result.end() );
-    cv_result=find_first( const_cast<const string&>(str2), string("abcd") );
-    BOOST_CHECK( cv_result.begin()==cv_result.end() );
-
-    cv_result=find_head( const_cast<const string&>(str2), 4 );
-    BOOST_CHECK( string( cv_result.begin(), cv_result.end() )== string("abc") );
-    cv_result=find_tail( const_cast<const string&>(str2), 4 );
-    BOOST_CHECK( string( cv_result.begin(), cv_result.end() )== string("abc") );
-
-    // Empty string test
-    BOOST_CHECKPOINT( "empty" );
-    
-    nc_result=find_first( str3, string("abcd") );
-    BOOST_CHECK( nc_result.begin()==nc_result.end() );
-    nc_result=find_first( str1, string("") );
-    BOOST_CHECK( nc_result.begin()==nc_result.end() );
-
-    cv_result=find_first( const_cast<const string&>(str3), string("abcd") );
-    BOOST_CHECK( cv_result.begin()==cv_result.end() );
-    cv_result=find_first( const_cast<const string&>(str1), string("") );
-    BOOST_CHECK( cv_result.begin()==cv_result.end() ); 
-
-    // iterator_range specific tests
-    ostringstream osstr;
-    osstr << find_first( str1, "abc" );
-    BOOST_CHECK( osstr.str()=="abc" );
-}
-
-// test main 
-int test_main( int, char*[] )
-{
-    find_test();
-    
-    return 0;
-}

string/test/predicate_test.cpp

@@ -1,125 +0,0 @@
-//  Boost string_algo library predicate_test.cpp file  ------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <vector>
-#include <iostream>
-#include <functional>
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/test/test_tools.hpp>
-
-using namespace std;
-using namespace boost;
-
-void predicate_test()
-{
-    string str1("123xxx321");
-    string str1_prefix("123");
-    string str2("abc");
-    string str3("");
-    string str4("abc");
-    vector<int> vec1( str1.begin(), str1.end() );
-
-    // Basic tests
-    BOOST_CHECK( starts_with( str1, string("123") ) );
-    BOOST_CHECK( !starts_with( str1, string("1234") ) );
-
-    BOOST_CHECK( istarts_with( "aBCxxx", "abc" ) );
-    BOOST_CHECK( !istarts_with( "aBCxxx", "abcd" ) );
-
-    BOOST_CHECK( ends_with( str1, string("321") ) );
-    BOOST_CHECK( !ends_with( str1, string("123") ) );
-
-    BOOST_CHECK( iends_with( "aBCxXx", "XXX" ) );
-    BOOST_CHECK( !iends_with( "aBCxxX", "xXXX" ) );
-
-    BOOST_CHECK( contains( str1, string("xxx") ) );
-    BOOST_CHECK( !contains( str1, string("yyy") ) );
-
-    BOOST_CHECK( icontains( "123XxX321", "xxx" ) );
-    BOOST_CHECK( !icontains( "123xXx321", "yyy" ) );
-
-    BOOST_CHECK( equals( str2, string("abc") ) );
-    BOOST_CHECK( !equals( str1, string("yyy") ) );
-
-    BOOST_CHECK( iequals( "AbC", "abc" ) );
-    BOOST_CHECK( !iequals( "aBc", "yyy" ) );
-
-    // multi-type comparison test
-    BOOST_CHECK( starts_with( vec1, string("123") ) );
-    BOOST_CHECK( ends_with( vec1, string("321") ) );
-    BOOST_CHECK( contains( vec1, string("xxx") ) );
-    BOOST_CHECK( equals( vec1, str1 ) );
-
-    // overflow test
-    BOOST_CHECK( !starts_with( str2, string("abcd") ) );
-    BOOST_CHECK( !ends_with( str2, string("abcd") ) );
-    BOOST_CHECK( !contains( str2, string("abcd") ) );
-    BOOST_CHECK( !equals( str2, string("abcd") ) );
-
-    // equal test
-    BOOST_CHECK( starts_with( str2, string("abc") ) );
-    BOOST_CHECK( ends_with( str2, string("abc") ) );
-    BOOST_CHECK( contains( str2, string("abc") ) );
-    BOOST_CHECK( equals( str2, string("abc") ) );
-
-    //! Empty string test
-    BOOST_CHECK( starts_with( str2, string("") ) );
-    BOOST_CHECK( ends_with( str2, string("") ) );
-    BOOST_CHECK( contains( str2, string("") ) );
-    BOOST_CHECK( equals( str3, string("") ) );
-
-    //! Container compatibility test
-    BOOST_CHECK( starts_with( "123xxx321", "123" ) );
-    BOOST_CHECK( ends_with( "123xxx321", "321" ) );
-    BOOST_CHECK( contains( "123xxx321", "xxx" ) );
-    BOOST_CHECK( equals( "123xxx321", "123xxx321" ) );
-}
-
-#define TEST_CLASS( Pred, YesInput, NoInput )\
-{\
-    BOOST_CHECK( all( string(YesInput), Pred ) );\
-    BOOST_CHECK( !all( string(NoInput), Pred ) );\
-}
-
-void classification_test()
-{
-    TEST_CLASS( is_space(), "\n\r\t ", "..." );
-    TEST_CLASS( is_alnum(), "ab129ABc", "_ab129ABc" );
-    TEST_CLASS( is_alpha(), "abc", "abc1" );
-    TEST_CLASS( is_cntrl(), "\n\t\r", "..." );
-    TEST_CLASS( is_digit(), "1234567890", "abc" );
-    TEST_CLASS( is_graph(), "123abc.,", "  \t" );
-    TEST_CLASS( is_lower(), "abc", "Aasdf" );
-    TEST_CLASS( is_print(), "abs", "\003\004asdf" );
-    TEST_CLASS( is_punct(), ".,;\"", "abc" );
-    TEST_CLASS( is_upper(), "ABC", "aBc" );
-    TEST_CLASS( is_xdigit(), "ABC123", "XFD" );
-    TEST_CLASS( is_any_of( string("abc") ), "aaabbcc", "aaxb" );
-    TEST_CLASS( is_any_of( "abc" ), "aaabbcc", "aaxb" );
-    TEST_CLASS( is_from_range( 'a', 'c' ), "aaabbcc", "aaxb" );
-
-    TEST_CLASS( !is_classified(std::ctype_base::space), "...", "..\n\r\t " );
-    TEST_CLASS( ( !is_any_of("abc") && is_from_range('a','e') ) || is_space(), "d e", "abcde" );
-}
-
-#undef TEST_CLASS
-
-// test main 
-int test_main( int, char*[] )
-{
-    predicate_test();
-    classification_test();
-    
-    return 0;
-}

string/test/regex_test.cpp

@@ -1,136 +0,0 @@
-//  Boost string_algo library substr_test.cpp file  ------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <vector>
-#include <iostream>
-#include <boost/regex.hpp>
-#include <boost/algorithm/string/sequence_traits.hpp>
-#include <boost/algorithm/string/regex.hpp>
-#include <boost/test/test_tools.hpp>
-
-using namespace std;
-using namespace boost;
-
-static void find_test()
-{
-    string str1("123a1cxxxa23cXXXa456c321");
-    char* pch1="123a1cxxxa23cXXXa456c321";
-    regex rx("a[0-9]+c");
-    vector<int> vec1( str1.begin(), str1.end() );
-    vector<string> tokens;
-
-    // find results
-    iterator_range<string::iterator> nc_result;
-    iterator_range<string::const_iterator> cv_result;
-    
-    iterator_range<vector<int>::iterator> nc_vresult;
-    iterator_range<vector<int>::const_iterator> cv_vresult;
-
-    iterator_range<const char*> ch_result;
-
-    // basic tests
-    nc_result=find_regex( str1, rx );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
-
-    cv_result=find_regex( str1, rx );
-    BOOST_CHECK( 
-        (distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
-        (distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
-
-    ch_result=find_regex( pch1, rx );
-    BOOST_CHECK(( (ch_result.begin() - pch1 ) == 3) && ( (ch_result.end() - pch1 ) == 6 ) );
-
-    // multi-type comparison test
-    nc_vresult=find_regex( vec1, rx );
-    BOOST_CHECK( 
-        (distance<vector<int>::const_iterator>( vec1.begin(),nc_vresult.begin()) == 3) &&
-        (distance<vector<int>::const_iterator>( vec1.begin(),nc_vresult.end()) == 6) );
-
-    cv_vresult=find_regex( vec1, rx );
-    BOOST_CHECK( 
-        (distance<vector<int>::const_iterator>( vec1.begin(),cv_vresult.begin()) == 3) &&
-        (distance<vector<int>::const_iterator>( vec1.begin(),cv_vresult.end()) == 6) );
-
-    // find_all_regex test
-    find_all_regex( tokens, str1, rx );
-
-    BOOST_REQUIRE( tokens.size()==3 );
-    BOOST_CHECK( tokens[0]==string("a1c") );
-    BOOST_CHECK( tokens[1]==string("a23c") );
-    BOOST_CHECK( tokens[2]==string("a456c") );
-
-    // split_regex test
-    split_regex(    tokens, str1, rx );
-
-    BOOST_REQUIRE( tokens.size()==4 );
-    BOOST_CHECK( tokens[0]==string("123") );
-    BOOST_CHECK( tokens[1]==string("xxx") );
-    BOOST_CHECK( tokens[2]==string("XXX") );
-    BOOST_CHECK( tokens[3]==string("321") );
-
-}
-
-static void replace_test()
-{
-    string str1("123a1cxxxa23cXXXa456c321");
-    regex rx1("a([0-9]+)c");
-    regex rx2("([xX]+)");
-    regex rx3("_[^_]*_");
-    string fmt1("_A$1C_");
-    string fmt2("_xXx_");
-    vector<int> vec1( str1.begin(), str1.end() );
-
-    // inmutable tests
-    
-    // basic tests
-    BOOST_CHECK( replace_regex_copy( str1, rx1, fmt1 )==string("123_A1C_xxxa23cXXXa456c321") );
-    BOOST_CHECK( replace_all_regex_copy( str1, rx1, fmt1 )==string("123_A1C_xxx_A23C_XXX_A456C_321") );
-    BOOST_CHECK( erase_regex_copy( str1, rx1 )==string("123xxxa23cXXXa456c321") );
-    BOOST_CHECK( erase_all_regex_copy( str1, rx1 )==string(string("123xxxXXX321")) );
-
-    // output iterator variants test
-    string strout;
-    replace_regex_copy( back_inserter(strout), str1, rx1, fmt1 );
-    BOOST_CHECK( strout==string("123_A1C_xxxa23cXXXa456c321") );
-    strout.clear();
-    replace_all_regex_copy( back_inserter(strout), str1, rx1, fmt1 );
-    BOOST_CHECK( strout==string("123_A1C_xxx_A23C_XXX_A456C_321") );
-    strout.clear();
-    erase_regex_copy( back_inserter(strout), str1, rx1 );
-    BOOST_CHECK( strout==string("123xxxa23cXXXa456c321") );
-    strout.clear();
-    erase_all_regex_copy( back_inserter(strout), str1, rx1 );
-    BOOST_CHECK( strout==string("123xxxXXX321") );
-    strout.clear();
-
-    // in-place test
-    replace_regex( str1, rx1, fmt2 );
-    BOOST_CHECK( str1==string("123_xXx_xxxa23cXXXa456c321") );
-
-    replace_all_regex( str1, rx2, fmt1 );
-    BOOST_CHECK( str1==string("123__AxXxC___AxxxC_a23c_AXXXC_a456c321") );
-    erase_regex( str1, rx3 );
-    BOOST_CHECK( str1==string("123AxXxC___AxxxC_a23c_AXXXC_a456c321") );
-    erase_all_regex( str1, rx3 );
-    BOOST_CHECK( str1==string("123AxXxCa23ca456c321") );
-}
-
-int test_main( int, char*[] )
-{
-    find_test();
-    replace_test();
-
-    return 0;
-}

string/test/replace_test.cpp

@@ -1,254 +0,0 @@
-//  Boost string_algo library substr_test.cpp file  ------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <vector>
-#include <list>
-#include <iostream>
-
-#include <boost/algorithm/string/std/list_traits.hpp>
-#include <boost/algorithm/string/std/string_traits.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/algorithm/string/erase.hpp>
-
-// equals predicate is used for result comparison
-#include <boost/algorithm/string/predicate.hpp>
-
-#include <boost/test/test_tools.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-
-using namespace std;
-using namespace boost;
-
-void sequence_traits_test()
-{
-    // basic_string traits
-    BOOST_CHECK( boost::algorithm::has_native_replace<string>::value );
-    BOOST_CHECK( !boost::algorithm::has_stable_iterators<string>::value );
-    BOOST_CHECK( !boost::algorithm::has_const_time_insert<string>::value );    
-    BOOST_CHECK( !boost::algorithm::has_const_time_erase<string>::value ); 
-
-    // vector traits
-    BOOST_CHECK( !boost::algorithm::has_native_replace< vector<char> >::value );
-    BOOST_CHECK( !boost::algorithm::has_stable_iterators< vector<char> >::value );
-    BOOST_CHECK( !boost::algorithm::has_const_time_insert< vector<char> >::value );    
-    BOOST_CHECK( !boost::algorithm::has_const_time_erase< vector<char> >::value ); 
-
-    // list traits
-    BOOST_CHECK( !boost::algorithm::has_native_replace< list<char> >::value );
-    BOOST_CHECK( boost::algorithm::has_stable_iterators< list<char> >::value );
-    BOOST_CHECK( boost::algorithm::has_const_time_insert< list<char> >::value );   
-    BOOST_CHECK( boost::algorithm::has_const_time_erase< list<char> >::value );    
-}
-
-// Combine tests for all variants of the algorithm
-#define TEST_ALGO( Algo, Input, Params, Output ) \
-{\
-    BOOST_CHECKPOINT( #Algo " - Copy" );\
-\
-    string str1(Input);\
-\
-    /* Copy test */ \
-    BOOST_CHECK( Algo##_copy( str1, BOOST_PP_SEQ_ENUM( Params ) )==Output );\
-\
-    BOOST_CHECKPOINT( #Algo " - Iterator" );\
-    /* Iterator test */\
-    string strout;\
-    Algo##_copy( back_inserter(strout), str1, BOOST_PP_SEQ_ENUM( Params ) );\
-    BOOST_CHECK( strout==Output ); \
-\
-    /* In-place test */\
-    vector<char> vec1( str1.begin(), str1.end() );\
-    list<char> list1( str1.begin(), str1.end() );\
-\
-    BOOST_CHECKPOINT( #Algo " - Inplace(string)" );\
-    Algo( str1, BOOST_PP_SEQ_ENUM( Params ) ); \
-    BOOST_CHECK( equals( str1, Output ) ); \
-\
-    BOOST_CHECKPOINT( #Algo " - Inplace(vector)" );\
-    Algo( vec1, BOOST_PP_SEQ_ENUM( Params ) ); \
-    BOOST_CHECK( equals( vec1, Output ) );\
-\
-    BOOST_CHECKPOINT( #Algo " - Inplace(list)" );\
-    Algo( list1, BOOST_PP_SEQ_ENUM( Params ) ); \
-    BOOST_CHECK( equals( list1, Output ) );\
-}
-
-void replace_test()
-{
-    // replace first
-    TEST_ALGO( replace_first, "1abc3abc2", (string("abc"))(string("YYY")), string("1YYY3abc2") );
-    TEST_ALGO( ireplace_first, "1AbC3abc2", ("aBc")("YYY"), string("1YYY3abc2") );
-    TEST_ALGO( replace_first, "1abc3abc2", (string("abc"))(string("Z")), string("1Z3abc2") );
-    TEST_ALGO( replace_first, "1abc3abc2", (string("abc"))(string("XXXX")), string("1XXXX3abc2") );
-    TEST_ALGO( replace_first, "1abc3abc2", (string(""))(string("XXXX")), string("1abc3abc2") );
-    TEST_ALGO( replace_first, "1abc3abc2", ("")("XXXX"), string("1abc3abc2") );
-    TEST_ALGO( replace_first, "", (string(""))(string("XXXX")), string("") );
-    TEST_ALGO( erase_first, "1abc3abc2", (string("abc")), string("13abc2") );
-    TEST_ALGO( ierase_first, "1aBc3abc2", ("abC"), "13abc2" );
-    TEST_ALGO( erase_first, "1abc3abc2", ("abc"), "13abc2" );
-    TEST_ALGO( erase_first, "1abc3abc2", (string("")), string("1abc3abc2") );
-    TEST_ALGO( erase_first, "", (string("abc")), string("") );
-
-    // replace last
-    TEST_ALGO( replace_last, "1abc3abc2", (string("abc"))(string("YYY")), string("1abc3YYY2") );
-    TEST_ALGO( ireplace_last, "1abc3AbC2", ("aBc")("YYY"), string("1abc3YYY2") );
-    TEST_ALGO( replace_last, "1abc3abc2", (string("abc"))(string("Z")), string("1abc3Z2") );
-    TEST_ALGO( replace_last, "1abc3abc2", (string("abc"))(string("XXXX")), string("1abc3XXXX2") );
-    TEST_ALGO( replace_last, "1abc3abc2", ("abc")("XXXX"), string("1abc3XXXX2") );
-    TEST_ALGO( replace_last, "", (string(""))(string("XXXX")), string("") );
-    TEST_ALGO( erase_last, "1abc3abc2", (string("abc")), string("1abc32") );
-    TEST_ALGO( ierase_last, "1aBc3aBc2", ("ABC"), string("1aBc32") );
-    TEST_ALGO( erase_last, "1abc3abc2", ("abc"), string("1abc32") );
-    TEST_ALGO( erase_last, "1abc3abc2", (string("")), string("1abc3abc2") );
-    TEST_ALGO( erase_last, "", (string("abc")), string("") );
-
-    // replace all
-    TEST_ALGO( replace_all, "1abc3abc2", (string("abc"))(string("YYY")), string("1YYY3YYY2") );
-    TEST_ALGO( ireplace_all, "1aBc3AbC2", ("abC")("YYY"), string("1YYY3YYY2") );
-    TEST_ALGO( replace_all, "1abc3abc2", (string("abc"))(string("Z")), string("1Z3Z2") );
-    TEST_ALGO( replace_all, "1abc3abc2", (string("abc"))(string("XXXX")), string("1XXXX3XXXX2") );
-    TEST_ALGO( replace_all, "1abc3abc2", ("abc")("XXXX"), string("1XXXX3XXXX2") );
-    TEST_ALGO( replace_all, "", (string(""))(string("XXXX")), string("") );
-    TEST_ALGO( erase_all, "1abc3abc2", (string("abc")), string("132") );
-    TEST_ALGO( ierase_all, "1aBc3aBc2", ("aBC"), string("132") );
-    TEST_ALGO( erase_all, "1abc3abc2", ("abc"), string("132") );
-    TEST_ALGO( erase_all, "1abc3abc2", (string("")), string("1abc3abc2") );
-    TEST_ALGO( erase_all, "", (string("abc")), string("") );
-
-    // replace nth
-    TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(0)(string("YYY")), string("1YYY3abc2") );
-    TEST_ALGO( ireplace_nth, "1AbC3abc2", ("aBc")(0)("YYY"), string("1YYY3abc2") );
-    TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(0)(string("Z")), string("1Z3abc2") );
-    TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(0)(string("XXXX")), string("1XXXX3abc2") );
-    TEST_ALGO( replace_nth, "1abc3abc2", ("abc")(0)("XXXX"), string("1XXXX3abc2") );
-    TEST_ALGO( replace_nth, "1abc3abc2", (string(""))(0)(string("XXXX")), string("1abc3abc2") );
-    TEST_ALGO( replace_nth, "", (string(""))(0)(string("XXXX")), string("") );
-    TEST_ALGO( erase_nth, "1abc3abc2", (string("abc"))(0), string("13abc2") );
-    TEST_ALGO( ierase_nth, "1aBc3aBc2", ("ABC")(0), string("13aBc2") );
-    TEST_ALGO( erase_nth, "1abc3abc2", ("abc")(0), string("13abc2") );
-    TEST_ALGO( erase_nth, "1abc3abc2", (string(""))(0), string("1abc3abc2") );
-    TEST_ALGO( erase_nth, "", (string("abc"))(0), string("") );
-    TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(1)(string("YYY")), string("1abc3YYY2") );
-    TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(2)(string("YYY")), string("1abc3abc2") );
-
-    // replace head
-    TEST_ALGO( replace_head, "abc3abc2", (3)(string("YYY")), string("YYY3abc2") );
-    TEST_ALGO( replace_head, "abc3abc2", (3)("YYY"), string("YYY3abc2") );
-    TEST_ALGO( replace_head, "abc", (3)(string("Z")), string("Z") );
-    TEST_ALGO( replace_head, "abc", (6)(string("XXXX")), string("XXXX") );
-    TEST_ALGO( replace_head, "abc3abc2", (0)(string("XXXX")), string("abc3abc2") );
-    TEST_ALGO( replace_head, "", (4)(string("XXXX")), string("") );
-    TEST_ALGO( erase_head, "abc3abc2", (3), string("3abc2") );
-    TEST_ALGO( erase_head, "abc3abc2", (0), string("abc3abc2") );
-    TEST_ALGO( erase_head, "", (4), string("") );
-
-    // replace tail
-    TEST_ALGO( replace_tail, "abc3abc", (3)(string("YYY")), string("abc3YYY") );
-    TEST_ALGO( replace_tail, "abc3abc", (3)("YYY"), string("abc3YYY") );
-    TEST_ALGO( replace_tail, "abc", (3)(string("Z")), string("Z") );
-    TEST_ALGO( replace_tail, "abc", (6)(string("XXXX")), string("XXXX") );
-    TEST_ALGO( replace_tail, "abc3abc", (0)(string("XXXX")), string("abc3abc") );
-    TEST_ALGO( replace_tail, "", (4)(string("XXXX")), string("") );
-    TEST_ALGO( erase_tail, "abc3abc", (3), string("abc3") );
-    TEST_ALGO( erase_tail, "abc3abc", (0), string("abc3abc") );
-    TEST_ALGO( erase_tail, "", (4), string("") );
-
-    // replace_range
-    {
-        BOOST_CHECKPOINT( "replace_range" );
-
-        string str1("1abc3abc2");
-        BOOST_CHECK( 
-            replace_range_copy( 
-                str1, 
-                make_iterator_range(str1.begin()+1, str1.begin()+4),
-                string("XXX") )==string("1XXX3abc2") );
-
-        string strout;
-        replace_range_copy( 
-                back_inserter( strout ),
-                str1, 
-                make_iterator_range(str1.begin()+1, str1.begin()+4),
-                string("XXX") );
-        BOOST_CHECK( strout==string("1XXX3abc2") );
-
-        replace_range( 
-                str1, 
-                make_iterator_range(str1.begin()+1, str1.begin()+4),
-                string("XXX") );
-        BOOST_CHECK( str1==string("1XXX3abc2") );
-    }
-    // erase_range
-    {
-        BOOST_CHECKPOINT( "erase_range" );
-
-        string str1("1abc3abc2");
-        BOOST_CHECK( 
-        erase_range_copy( 
-                str1, 
-                make_iterator_range(str1.begin()+1, str1.begin()+4))==string("13abc2") );
-
-        string strout;
-        erase_range_copy( 
-                back_inserter( strout ),
-                str1, 
-                make_iterator_range(str1.begin()+1, str1.begin()+4));
-        BOOST_CHECK( strout==string("13abc2") );
-
-        erase_range( 
-                str1, 
-                make_iterator_range(str1.begin()+1, str1.begin()+4));
-        BOOST_CHECK( str1==string("13abc2") );
-    }
-
-    // container traits complatibility tests
-    {
-        string strout;
-        replace_first_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" );
-        BOOST_CHECK( strout==string("1YYY3abc2") ); 
-    }
-    {
-        string strout;
-        replace_last_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" );
-        BOOST_CHECK( strout==string("1abc3YYY2") ); 
-    }   
-    {
-        string strout;
-        replace_all_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" );
-        BOOST_CHECK( strout==string("1YYY3YYY2") ); 
-    }   
-    {
-        string strout;
-        replace_nth_copy( back_inserter(strout), "1abc3abc2", "abc", 1, "YYY" );
-        BOOST_CHECK( strout==string("1abc3YYY2") ); 
-    }   
-    {
-        string strout;
-        replace_head_copy( back_inserter(strout), "abc3abc2", 3 , "YYY" );
-        BOOST_CHECK( strout==string("YYY3abc2") ); 
-    }   
-    {
-        string strout;
-        replace_tail_copy( back_inserter(strout), "abc3abc", 3 , "YYY" );
-        BOOST_CHECK( strout==string("abc3YYY") ); 
-    }   
-}
-
-// test main 
-int test_main( int, char*[] )
-{
-    sequence_traits_test(); 
-    replace_test();
-    
-    return 0;
-}

string/test/split_test.cpp

@@ -1,123 +0,0 @@
-//  Boost string_algo library iterator_test.cpp file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <vector>
-#include <iostream>
-
-#include <boost/test/test_tools.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/classification.hpp>
-
-// equals predicate is used for result comparison
-#include <boost/algorithm/string/predicate.hpp>
-
-
-using namespace std;
-using namespace boost;
-
-template< typename T1, typename T2 >
-void deep_compare( const T1& X, const T2& Y )
-{
-    BOOST_REQUIRE( X.size() == Y.size() );
-    for( unsigned int nIndex=0; nIndex<X.size(); ++nIndex )
-    {
-        BOOST_CHECK( equals( X[nIndex], Y[nIndex] ) );
-    }
-}
-
-void iterator_test()
-{
-    string str1("xx-abc--xx-abb");
-    string str2("Xx-abc--xX-abb");
-    string str3("xx");
-    char* pch1="xx-abc--xx-abb";
-    vector<string> tokens;
-    vector< vector<int> > vtokens;
-
-    ifind_all(
-        tokens,
-        str2,
-        "xx" );
-
-    BOOST_REQUIRE( tokens.size()==2 );
-    BOOST_CHECK( tokens[0]==string("Xx") );
-    BOOST_CHECK( tokens[1]==string("xX") );
-
-    // find_all tests
-    find_all(
-        tokens,
-        str1,
-        "xx" );
-
-    BOOST_REQUIRE( tokens.size()==2 );
-    BOOST_CHECK( tokens[0]==string("xx") );
-    BOOST_CHECK( tokens[1]==string("xx") );
-
-
-    find_all(
-        vtokens,
-        str1,
-        string("xx") );
-    deep_compare( tokens, vtokens );
-
-    // split tests
-    split(
-        tokens,
-        str1,
-        is_any_of("x"),
-        token_compress_on );
-
-    BOOST_REQUIRE( tokens.size()==3 );
-    BOOST_CHECK( tokens[0]==string("") );
-    BOOST_CHECK( tokens[1]==string("-abc--") );
-    BOOST_CHECK( tokens[2]==string("-abb") );
-
-    split(
-        tokens,
-        pch1,
-        is_any_of("x"),
-        token_compress_on );
-
-    BOOST_REQUIRE( tokens.size()==3 );
-    BOOST_CHECK( tokens[0]==string("") );
-    BOOST_CHECK( tokens[1]==string("-abc--") );
-    BOOST_CHECK( tokens[2]==string("-abb") );
-
-    split(
-        vtokens,
-        str1,
-        is_any_of("x"),
-        token_compress_on );
-    deep_compare( tokens, vtokens );
-
-    split(
-        tokens,
-        str1,
-        is_punct(),
-        token_compress_off );
-
-    BOOST_REQUIRE( tokens.size()==5 );
-    BOOST_CHECK( tokens[0]==string("xx") );
-    BOOST_CHECK( tokens[1]==string("abc") );
-    BOOST_CHECK( tokens[2]==string("") );
-    BOOST_CHECK( tokens[3]==string("xx") );
-    BOOST_CHECK( tokens[4]==string("abb") );
-}
-
-// test main 
-int test_main( int, char*[] )
-{
-    iterator_test();
-    
-    return 0;
-}

string/test/trim_test.cpp

@@ -1,117 +0,0 @@
-//  Boost string_algo library trim_test.cpp file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to 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 for updates, documentation, and revision history.
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <iostream>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/test/test_tools.hpp>
-
-using namespace std;
-using namespace boost;
-
-void trim_test()
-{
-    string str1("     1x x x x1     ");
-    string str2("     2x x x x2     ");
-    string str3("    ");
-
-    // *** value passing tests *** //
-
-    // general string test
-    BOOST_CHECK( trim_left_copy( str1 )=="1x x x x1     " ) ;
-    BOOST_CHECK( trim_right_copy( str1 )=="     1x x x x1" ) ;
-    BOOST_CHECK( trim_copy( str1 )=="1x x x x1" ) ;
-
-    // spaces-only string test
-    BOOST_CHECK( trim_left_copy( str3 )=="" );
-    BOOST_CHECK( trim_right_copy( str3 )=="" );
-    BOOST_CHECK( trim_copy( str3 )=="" );
-
-    // empty string check 
-    BOOST_CHECK( trim_left_copy( string("") )=="" );
-    BOOST_CHECK( trim_right_copy( string("") )=="" );
-    BOOST_CHECK( trim_copy( string("") )=="" );
-
-    // iterator tests
-    string str;
-    trim_left_copy_if( std::back_inserter(str), str1, is_space() );
-    BOOST_CHECK( str=="1x x x x1     " );
-
-    str.clear();
-    trim_right_copy_if( std::back_inserter(str), str1, is_space() );
-    BOOST_CHECK( str=="     1x x x x1" );
-
-    str.clear();
-    trim_copy_if( std::back_inserter(str), str1, is_space() );
-    BOOST_CHECK( str=="1x x x x1" );
-
-    str.clear();
-    trim_left_copy_if( 
-        std::back_inserter(str), 
-        "     1x x x x1     ", 
-        is_space() );
-    BOOST_CHECK( str=="1x x x x1     " );
-
-    str.clear();
-    trim_right_copy_if( 
-        std::back_inserter(str), 
-        "     1x x x x1     ", 
-        is_space() );
-    BOOST_CHECK( str=="     1x x x x1" );
-
-    str.clear();
-    trim_copy_if( 
-        std::back_inserter(str), 
-        "     1x x x x1     ", 
-        is_space() );
-    BOOST_CHECK( str=="1x x x x1" );
-    // *** inplace tests *** //
-
-    // general string test
-    trim_left( str1 );
-    BOOST_CHECK( str1=="1x x x x1     " );
-    trim_right( str1 );
-    BOOST_CHECK( str1=="1x x x x1" );
-    trim( str2 );
-    BOOST_CHECK( str2=="2x x x x2" );
-    
-    // spaces-only string test
-    str3 = "    "; trim_left( str3 );
-    BOOST_CHECK( str3=="" );
-    str3 = "    "; trim_right( str3 );
-    BOOST_CHECK( str3=="" );
-    str3 = "    "; trim( str3 );
-    BOOST_CHECK( str3=="" );
-
-    // empty string check 
-    str3 = ""; trim_left( str3 );
-    BOOST_CHECK( str3=="" );
-    str3 = ""; trim_right( str3 );
-    BOOST_CHECK( str3=="" );
-    str3 = ""; trim( str3 );
-    BOOST_CHECK( str3=="" );
-
-    // *** non-standard predicate tests *** //
-    BOOST_CHECK( 
-        trim_copy_if( 
-            string("123abc456"), 
-            is_classified(std::ctype_base::digit) )=="abc" );
-    BOOST_CHECK( trim_copy_if( string("<>abc<>"), is_any_of( "<<>>" ) )=="abc" );
-}
-
-// test main 
-int test_main( int, char*[] )
-{
-    trim_test();
-    
-    return 0;
-}

sublibs

@@ -1 +0,0 @@
-The existance of this file tells the regression reporting programs that the directory contains sub-directories which are libraries.